@stacksjs/cli 0.58.58 → 0.58.61

package/dist/index.js

@@ -12,50 +12,34 @@ async function installStack(name, options) {
   return await installPkg(`@stacksjs/${name}`, { silent: true });
 }
 // src/cli.ts
-import cac from "cac";
-// package.json
-var version = "0.58.58";
-
-// src/cli.ts
+import {CAC} from "cac";
 function cli(name, options) {
   if (typeof name === "object") {
     options = name;
     name = options.name;
   }
-  const cli2 = cac(name || "buddy");
-  cli2.help();
-  cli2.version(options?.version || version);
-  return cli2;
-}
-function parseOptions() {
-  const options = cli().parse().options;
-  for (const key in options) {
-    if (options[key] === "true")
-      options[key] = true;
-    else if (options[key] === "false")
-      options[key] = false;
-  }
-  return options;
+  return new CAC(name || "buddy");
 }
 // src/exec.ts
-import process from "process";
+import process2 from "process";
 import {err, handleError, ok} from "@stacksjs/error-handling";
 import {ExitCode} from "@stacksjs/types";
 async function exec(command, options) {
   const cmd = Array.isArray(command) ? command : command.match(/(?:[^\s"]+|"[^"]*")+/g);
   if (!cmd)
     return err(handleError(`Failed to parse command: ${cmd}`, options));
-  if (options?.verbose)
-    console.log("exec", { command, cmd, options });
+  log2.debug("exec:", Array.isArray(command) ? command.join(" ") : command);
+  log2.debug("cmd:", cmd);
+  log2.debug("exec options:", options);
   const proc = Bun.spawn(cmd, {
     ...options,
-    stdout: options?.silent ? "ignore" : options?.stdin ? options.stdin : options?.stdout || "inherit",
-    stderr: options?.silent ? "ignore" : options?.stderr || "inherit",
+    stdout: options?.silent || options?.quiet ? "ignore" : options?.stdin ? options.stdin : options?.stdout || "inherit",
+    stderr: options?.silent || options?.quiet ? "ignore" : options?.stderr || "inherit",
     detached: options?.background || false,
     cwd: options?.cwd || import.meta.dir,
     onExit(_subprocess, exitCode, _signalCode, _error) {
       if (exitCode && exitCode !== ExitCode.Success)
-        process.exit(exitCode);
+        process2.exit(exitCode);
     }
   });
   if (options?.stdin === "pipe" && options.input) {
@@ -70,26 +54,341 @@ async function exec(command, options) {
   return err(handleError(`Failed to execute command: ${cmd.join(" ")}`));
 }
 async function execSync(command, options) {
-  const cmd = Array.isArray(command) ? command : command.split(" ");
+  log2.debug("Running execSync:", command);
+  log2.debug("execSync Options:", options);
+  const cmd = Array.isArray(command) ? command : command.match(/(?:[^\s"]+|"[^"]*")+/g);
+  if (!cmd) {
+    log2.error(`Failed to parse command: ${cmd}`, options);
+    process2.exit(ExitCode.FatalError);
+  }
   const proc = Bun.spawnSync(cmd, {
     ...options,
+    stdin: options?.stdin ?? "inherit",
     stdout: options?.stdout ?? "pipe",
     stderr: options?.stderr ?? "inherit",
     cwd: options?.cwd ?? import.meta.dir,
     onExit(_subprocess, exitCode, _signalCode, _error) {
       if (exitCode !== ExitCode.Success && exitCode)
-        process.exit(exitCode);
+        process2.exit(exitCode);
     }
   });
   return proc.stdout.toString();
 }
 
-// src/utilities.ts
+// src/utils.ts
 import * as kolorist from "kolorist";
-import {ansi256Bg, bgBlack, bgBlue, bgCyan, bgGray, bgGreen, bgLightBlue, bgLightCyan, bgLightGray, bgLightGreen, bgLightMagenta, bgLightRed, bgLightYellow, bgMagenta, bgRed, bgWhite, bgYellow, black, blue, bold, cyan, dim, gray, green, hidden, inverse, italic, lightBlue, lightCyan, lightGray, lightGreen, lightMagenta, lightRed, lightYellow, link, magenta, red, reset, strikethrough, underline, white, yellow, ansi256, trueColor, trueColorBg, stripColors} from "kolorist";
+
+// /home/runner/work/stacks/stacks/node_modules/consola/dist/utils.mjs
+import * as tty from "tty";
+var replaceClose = function(index, string, close, replace, head = string.slice(0, Math.max(0, index)) + replace, tail = string.slice(Math.max(0, index + close.length)), next = tail.indexOf(close)) {
+  return head + (next < 0 ? tail : replaceClose(next, tail, close, replace));
+};
+var clearBleed = function(index, string, open, close, replace) {
+  return index < 0 ? open + string + close : open + replaceClose(index, string, close, replace) + close;
+};
+var filterEmpty = function(open, close, replace = open, at = open.length + 1) {
+  return (string) => string || !(string === "" || string === undefined) ? clearBleed(("" + string).indexOf(close, at), string, open, close, replace) : "";
+};
+var init = function(open, close, replace) {
+  return filterEmpty(`\x1B[${open}m`, `\x1B[${close}m`, replace);
+};
+var createColors = function(useColor = isColorSupported) {
+  return useColor ? colorDefs : Object.fromEntries(Object.keys(colorDefs).map((key) => [key, String]));
+};
+var getColor = function(color, fallback = "reset") {
+  return colors[color] || colors[fallback];
+};
+var colorize = function(color, text) {
+  return getColor(color)(text);
+};
+var stripAnsi = function(text) {
+  return text.replace(new RegExp(ansiRegex, "g"), "");
+};
+var centerAlign = function(str, len, space = " ") {
+  const free = len - str.length;
+  if (free <= 0) {
+    return str;
+  }
+  const freeLeft = Math.floor(free / 2);
+  let _str = "";
+  for (let i = 0;i < len; i++) {
+    _str += i < freeLeft || i >= freeLeft + str.length ? space : str[i - freeLeft];
+  }
+  return _str;
+};
+var rightAlign = function(str, len, space = " ") {
+  const free = len - str.length;
+  if (free <= 0) {
+    return str;
+  }
+  let _str = "";
+  for (let i = 0;i < len; i++) {
+    _str += i < free ? space : str[i - free];
+  }
+  return _str;
+};
+var leftAlign = function(str, len, space = " ") {
+  let _str = "";
+  for (let i = 0;i < len; i++) {
+    _str += i < str.length ? str[i] : space;
+  }
+  return _str;
+};
+var align = function(alignment, str, len, space = " ") {
+  switch (alignment) {
+    case "left": {
+      return leftAlign(str, len, space);
+    }
+    case "right": {
+      return rightAlign(str, len, space);
+    }
+    case "center": {
+      return centerAlign(str, len, space);
+    }
+    default: {
+      return str;
+    }
+  }
+};
+var box = function(text, _opts = {}) {
+  const opts = {
+    ..._opts,
+    style: {
+      ...defaultStyle,
+      ..._opts.style
+    }
+  };
+  const textLines = text.split("\n");
+  const boxLines = [];
+  const _color = getColor(opts.style.borderColor);
+  const borderStyle = {
+    ...typeof opts.style.borderStyle === "string" ? boxStylePresets[opts.style.borderStyle] || boxStylePresets.solid : opts.style.borderStyle
+  };
+  if (_color) {
+    for (const key in borderStyle) {
+      borderStyle[key] = _color(borderStyle[key]);
+    }
+  }
+  const paddingOffset = opts.style.padding % 2 === 0 ? opts.style.padding : opts.style.padding + 1;
+  const height = textLines.length + paddingOffset;
+  const width = Math.max(...textLines.map((line) => line.length)) + paddingOffset;
+  const widthOffset = width + paddingOffset;
+  const leftSpace = opts.style.marginLeft > 0 ? " ".repeat(opts.style.marginLeft) : "";
+  if (opts.style.marginTop > 0) {
+    boxLines.push("".repeat(opts.style.marginTop));
+  }
+  if (opts.title) {
+    const left = borderStyle.h.repeat(Math.floor((width - stripAnsi(opts.title).length) / 2));
+    const right = borderStyle.h.repeat(width - stripAnsi(opts.title).length - stripAnsi(left).length + paddingOffset);
+    boxLines.push(`${leftSpace}${borderStyle.tl}${left}${opts.title}${right}${borderStyle.tr}`);
+  } else {
+    boxLines.push(`${leftSpace}${borderStyle.tl}${borderStyle.h.repeat(widthOffset)}${borderStyle.tr}`);
+  }
+  const valignOffset = opts.style.valign === "center" ? Math.floor((height - textLines.length) / 2) : opts.style.valign === "top" ? height - textLines.length - paddingOffset : height - textLines.length;
+  for (let i = 0;i < height; i++) {
+    if (i < valignOffset || i >= valignOffset + textLines.length) {
+      boxLines.push(`${leftSpace}${borderStyle.v}${" ".repeat(widthOffset)}${borderStyle.v}`);
+    } else {
+      const line = textLines[i - valignOffset];
+      const left = " ".repeat(paddingOffset);
+      const right = " ".repeat(width - stripAnsi(line).length);
+      boxLines.push(`${leftSpace}${borderStyle.v}${left}${line}${right}${borderStyle.v}`);
+    }
+  }
+  boxLines.push(`${leftSpace}${borderStyle.bl}${borderStyle.h.repeat(widthOffset)}${borderStyle.br}`);
+  if (opts.style.marginBottom > 0) {
+    boxLines.push("".repeat(opts.style.marginBottom));
+  }
+  return boxLines.join("\n");
+};
+var {
+  env = {},
+  argv = [],
+  platform = ""
+} = typeof process === "undefined" ? {} : process;
+var isDisabled = "NO_COLOR" in env || argv.includes("--no-color");
+var isForced = "FORCE_COLOR" in env || argv.includes("--color");
+var isWindows = platform === "win32";
+var isDumbTerminal = env.TERM === "dumb";
+var isCompatibleTerminal = tty && tty.isatty && tty.isatty(1) && env.TERM && !isDumbTerminal;
+var isCI = "CI" in env && (("GITHUB_ACTIONS" in env) || ("GITLAB_CI" in env) || ("CIRCLECI" in env));
+var isColorSupported = !isDisabled && (isForced || isWindows && !isDumbTerminal || isCompatibleTerminal || isCI);
+var colorDefs = {
+  reset: init(0, 0),
+  bold: init(1, 22, "\x1B[22m\x1B[1m"),
+  dim: init(2, 22, "\x1B[22m\x1B[2m"),
+  italic: init(3, 23),
+  underline: init(4, 24),
+  inverse: init(7, 27),
+  hidden: init(8, 28),
+  strikethrough: init(9, 29),
+  black: init(30, 39),
+  red: init(31, 39),
+  green: init(32, 39),
+  yellow: init(33, 39),
+  blue: init(34, 39),
+  magenta: init(35, 39),
+  cyan: init(36, 39),
+  white: init(37, 39),
+  gray: init(90, 39),
+  bgBlack: init(40, 49),
+  bgRed: init(41, 49),
+  bgGreen: init(42, 49),
+  bgYellow: init(43, 49),
+  bgBlue: init(44, 49),
+  bgMagenta: init(45, 49),
+  bgCyan: init(46, 49),
+  bgWhite: init(47, 49),
+  blackBright: init(90, 39),
+  redBright: init(91, 39),
+  greenBright: init(92, 39),
+  yellowBright: init(93, 39),
+  blueBright: init(94, 39),
+  magentaBright: init(95, 39),
+  cyanBright: init(96, 39),
+  whiteBright: init(97, 39),
+  bgBlackBright: init(100, 49),
+  bgRedBright: init(101, 49),
+  bgGreenBright: init(102, 49),
+  bgYellowBright: init(103, 49),
+  bgBlueBright: init(104, 49),
+  bgMagentaBright: init(105, 49),
+  bgCyanBright: init(106, 49),
+  bgWhiteBright: init(107, 49)
+};
+var colors = createColors();
+var ansiRegex = [
+  "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
+  "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))"
+].join("|");
+var boxStylePresets = {
+  solid: {
+    tl: "\u250C",
+    tr: "\u2510",
+    bl: "\u2514",
+    br: "\u2518",
+    h: "\u2500",
+    v: "\u2502"
+  },
+  double: {
+    tl: "\u2554",
+    tr: "\u2557",
+    bl: "\u255A",
+    br: "\u255D",
+    h: "\u2550",
+    v: "\u2551"
+  },
+  doubleSingle: {
+    tl: "\u2553",
+    tr: "\u2556",
+    bl: "\u2559",
+    br: "\u255C",
+    h: "\u2500",
+    v: "\u2551"
+  },
+  doubleSingleRounded: {
+    tl: "\u256D",
+    tr: "\u256E",
+    bl: "\u2570",
+    br: "\u256F",
+    h: "\u2500",
+    v: "\u2551"
+  },
+  singleThick: {
+    tl: "\u250F",
+    tr: "\u2513",
+    bl: "\u2517",
+    br: "\u251B",
+    h: "\u2501",
+    v: "\u2503"
+  },
+  singleDouble: {
+    tl: "\u2552",
+    tr: "\u2555",
+    bl: "\u2558",
+    br: "\u255B",
+    h: "\u2550",
+    v: "\u2502"
+  },
+  singleDoubleRounded: {
+    tl: "\u256D",
+    tr: "\u256E",
+    bl: "\u2570",
+    br: "\u256F",
+    h: "\u2550",
+    v: "\u2502"
+  },
+  rounded: {
+    tl: "\u256D",
+    tr: "\u256E",
+    bl: "\u2570",
+    br: "\u256F",
+    h: "\u2500",
+    v: "\u2502"
+  }
+};
+var defaultStyle = {
+  borderColor: "white",
+  borderStyle: "rounded",
+  valign: "center",
+  padding: 2,
+  marginLeft: 1,
+  marginTop: 1,
+  marginBottom: 1
+};
+
+// src/utils.ts
+import {
+ansi256Bg,
+bgBlack,
+bgBlue,
+bgCyan,
+bgGray,
+bgGreen,
+bgLightBlue,
+bgLightCyan,
+bgLightGray,
+bgLightGreen,
+bgLightMagenta,
+bgLightRed,
+bgLightYellow,
+bgMagenta,
+bgRed,
+bgWhite,
+bgYellow,
+black,
+blue,
+bold,
+cyan,
+dim,
+gray,
+green,
+hidden,
+inverse,
+italic,
+lightBlue,
+lightCyan,
+lightGray,
+lightGreen,
+lightMagenta,
+lightRed,
+lightYellow,
+link,
+magenta,
+red,
+reset,
+strikethrough,
+underline,
+white,
+yellow,
+ansi256,
+trueColor,
+trueColorBg,
+stripColors
+} from "kolorist";
 
 // src/console.ts
-import {log} from "@stacksjs/logging";
+import {log as log2, logger} from "@stacksjs/logging";
 import prompts from "prompts";
 
 class Prompt {
@@ -106,61 +405,61 @@ class Prompt {
   }
   async select(message, options) {
     if (this.isRequired())
-      return log.prompt(message, { ...options, type: "select", required: true });
-    return log.prompt(message, { ...options, type: "select" });
+      return logger.prompt(message, { ...options, type: "select", required: true });
+    return logger.prompt(message, { ...options, type: "select" });
   }
   async checkbox(message, options) {
     if (this.isRequired())
-      return log.prompt(message, { ...options, type: "multiselect", required: true });
-    return log.prompt(message, { ...options, type: "multiselect" });
+      return logger.prompt(message, { ...options, type: "multiselect", required: true });
+    return logger.prompt(message, { ...options, type: "multiselect" });
   }
   async confirm(message, options) {
     if (this.isRequired())
-      return log.prompt(message, { ...options, type: "confirm", required: true });
-    return log.prompt(message, { ...options, type: "confirm" });
+      return logger.prompt(message, { ...options, type: "confirm", required: true });
+    return logger.prompt(message, { ...options, type: "confirm" });
   }
   async input(message, options) {
     if (this.isRequired())
-      return log.prompt(message, { ...options, type: "text", required: true });
-    return log.prompt(message, { ...options, type: "text" });
+      return logger.prompt(message, { ...options, type: "text", required: true });
+    return logger.prompt(message, { ...options, type: "text" });
   }
   async password(message, options) {
     if (this.isRequired())
-      return log.prompt(message, { ...options, type: "password", required: true });
-    return log.prompt(message, { ...options, type: "password" });
+      return logger.prompt(message, { ...options, type: "password", required: true });
+    return logger.prompt(message, { ...options, type: "password" });
   }
   async number(message, options) {
     if (this.isRequired())
-      return log.prompt(message, { ...options, type: "numeral", required: true });
-    return log.prompt(message, { ...options, type: "numeral" });
+      return logger.prompt(message, { ...options, type: "numeral", required: true });
+    return logger.prompt(message, { ...options, type: "numeral" });
   }
   async multiselect(message, options) {
     if (this.isRequired())
-      return log.prompt(message, { ...options, type: "multiselect", required: true });
-    return log.prompt(message, { ...options, type: "multiselect" });
+      return logger.prompt(message, { ...options, type: "multiselect", required: true });
+    return logger.prompt(message, { ...options, type: "multiselect" });
   }
   async autocomplete(message, options) {
     if (this.isRequired())
-      return log.prompt(message, { ...options, type: "autocomplete", required: true });
-    return log.prompt(message, { ...options, type: "autocomplete" });
+      return logger.prompt(message, { ...options, type: "autocomplete", required: true });
+    return logger.prompt(message, { ...options, type: "autocomplete" });
   }
 }
-var prompt = new Prompt;
+var prompt = () => new Prompt;
 
 // src/run.ts
 async function runCommand(command, options) {
-  if (options?.verbose)
-    log.debug("Running command:", underline(italic(command)), "with options:", options);
+  log2.debug("runCommand:", command);
+  log2.debug("options:", options);
   return await exec(command, options);
 }
 async function runProcess(command, options) {
-  if (options?.verbose)
-    log.debug("Running command:", underline(italic(command)), "with options:", options);
+  log2.debug("runProcess:", italic(command));
+  log2.debug("runProcess Options:", options);
   return await exec(command, options);
 }
 async function runCommandSync(command, options) {
-  if (options?.verbose)
-    log.debug("Running command:", underline(italic(command)), "with options:", options);
+  log2.debug("runCommandSync:", italic(command));
+  log2.debug("runCommandSync Options:", options);
   const result = await execSync(command, options);
   return result;
 }
@@ -188,23 +487,35 @@ class Command {
     this.onSuccess = onSuccess;
   }
 }
+var command = {
+  run: async (command2, options) => {
+    return await runCommand(command2, options);
+  },
+  runSync: async (command2, options) => {
+    return await runCommand(command2, options);
+  }
+};
 // src/helpers.ts
 import {config as config2} from "@stacksjs/config";
 import {handleError as handleError2} from "@stacksjs/error-handling";
-import {log as log2} from "@stacksjs/logging";
+import {log as log3} from "@stacksjs/logging";
 import {ExitCode as ExitCode2} from "@stacksjs/types";
 import {bgCyan as bgCyan2, bold as bold2, cyan as cyan2, dim as dim2, gray as gray2, green as green2, italic as italic2} from "kolorist";
-async function intro(command, options) {
+// package.json
+var version = "0.58.61";
+
+// src/helpers.ts
+async function intro(command2, options) {
   return new Promise((resolve) => {
     if (options?.quiet === false) {
       console.log();
       console.log(cyan2(bold2("Stacks CLI")) + dim2(` v${version}`));
       console.log();
     }
-    let msg = `Running  ${bgCyan2(italic2(bold2(` ${command} `)))}`;
-    if (command === "buddy deploy")
-      msg = `Running  ${bgCyan2(italic2(bold2(` ${command} `)))}  for ${bold2(`${config2.app.name}`)} ${italic2(`via ${config2.app.url}`)}`;
-    log2.info(msg);
+    let msg = `Running  ${bgCyan2(italic2(bold2(` ${command2} `)))}`;
+    if (command2 === "buddy deploy")
+      msg = `Running  ${bgCyan2(italic2(bold2(` ${command2} `)))}  for ${bold2(`${config2.app.name}`)} ${italic2(`via ${config2.app.url}`)}`;
+    log3.info(msg);
     if (options?.showPerformance === false || options?.quiet)
       return resolve(0);
     return resolve(performance.now());
@@ -229,23 +540,25 @@ function outro(text, options, error) {
       if (opts.quiet === true)
         return resolve(ExitCode2.Success);
       if (error)
-        log2.error(`[${time.toFixed(2)}${opts.useSeconds ? "s" : "ms"}] Failed`);
+        log3.error(`[${time.toFixed(2)}${opts.useSeconds ? "s" : "ms"}] Failed`);
       else if (opts.type === "info")
-        console.log(`${dim2(gray2(`[${time.toFixed(2)}${opts.useSeconds ? "s" : "ms"}]`))} ${opts.message ?? "Complete"}`);
+        log3.info(`${dim2(gray2(`[${time.toFixed(2)}${opts.useSeconds ? "s" : "ms"}]`))} ${opts.message ?? "Complete"}`);
       else
-        console.log(`${dim2(gray2(bold2(`[${time.toFixed(2)}${opts.useSeconds ? "s" : "ms"}]`)))} ${bold2(green2(opts.message ?? "Complete"))}`);
+        log3.success(`${dim2(gray2(bold2(`[${time.toFixed(2)}${opts.useSeconds ? "s" : "ms"}]`)))} ${bold2(green2(opts.message ?? "Complete"))}`);
     } else {
       if (opts?.type === "info")
-        console.log(text);
+        log3.info(text);
       else if (opts?.type === "success" && opts?.quiet !== true)
-        log2.success(text);
+        log3.success(text);
     }
     return resolve(ExitCode2.Success);
   });
 }
 // src/parse.ts
-import process2 from "process";
+import process3 from "process";
 var isLongOption = function(arg) {
+  if (!arg)
+    return false;
   return arg.startsWith("--");
 };
 var isShortOption = function(arg) {
@@ -261,27 +574,29 @@ var parseValue = function(value) {
     return numberValue;
   return value.replace(/"/g, "");
 };
-var parseLongOption = function(arg, argv, index, options) {
+var parseLongOption = function(arg, argv2, index, options) {
   const [key, value] = arg.slice(2).split("=");
   if (value !== undefined) {
     options[key] = parseValue(value);
-  } else if (index + 1 < argv.length && !argv[index + 1].startsWith("-")) {
-    options[key] = argv[index + 1];
+  } else if (index + 1 < argv2.length && !argv2[index + 1].startsWith("-")) {
+    options[key] = argv2[index + 1];
     index++;
   } else {
     options[key] = true;
   }
   return index;
 };
-var parseShortOption = function(arg, argv, index, options) {
+var parseShortOption = function(arg, argv2, index, options) {
   const [key, value] = arg.slice(1).split("=");
-  if (value !== undefined) {
+  if (key === undefined)
+    return index;
+  if (value !== undefined && key !== undefined) {
     for (let j = 0;j < key.length; j++)
       options[key[j]] = parseValue(value);
   } else {
     for (let j = 0;j < key.length; j++) {
-      if (index + 1 < argv.length && j === key.length - 1 && !argv[index + 1].startsWith("-")) {
-        options[key[j]] = parseValue(argv[index + 1]);
+      if (index + 1 < argv2.length && j === key.length - 1 && !argv2[index + 1].startsWith("-")) {
+        options[key[j]] = parseValue(argv2[index + 1]);
         index++;
       } else {
         options[key[j]] = true;
@@ -290,22 +605,75 @@ var parseShortOption = function(arg, argv, index, options) {
   }
   return index;
 };
-function parseArgv(argv) {
-  if (argv === undefined)
-    argv = process2.argv.slice(2);
+function parseArgv(argv2) {
+  if (argv2 === undefined)
+    argv2 = process3.argv.slice(2);
   const args = [];
   const options = {};
-  for (let i = 0;i < argv.length; i++) {
-    const arg = argv[i];
+  for (let i = 0;i < argv2.length; i++) {
+    const arg = argv2[i];
+    if (!arg)
+      continue;
     if (isLongOption(arg))
-      i = parseLongOption(arg, argv, i, options);
+      i = parseLongOption(arg, argv2, i, options);
     else if (isShortOption(arg))
-      i = parseShortOption(arg, argv, i, options);
+      i = parseShortOption(arg, argv2, i, options);
     else
       args.push(arg);
   }
   return { args, options };
 }
+function parseArgs(argv2) {
+  if (argv2 === undefined)
+    argv2 = process3.argv.slice(2);
+  return parseArgv(argv2).args;
+}
+function parseOptions(options) {
+  options = options || {};
+  const args = process3.argv.slice(2);
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg?.startsWith("--")) {
+      const key = arg.substring(2);
+      const camelCaseKey = key.replace(/-([a-z])/gi, (g) => g[1] ? g[1].toUpperCase() : "");
+      if (i + 1 < args.length) {
+        if (args[i + 1] === "true" || args[i + 1] === "false") {
+          options[camelCaseKey] = args[i + 1] === "true";
+          i++;
+        } else {
+          options[camelCaseKey] = args[i + 1];
+          i++;
+        }
+      } else {
+        options[camelCaseKey] = true;
+      }
+    }
+  }
+  if (Object.keys(options).length === 0)
+    return { dryRun: false, quiet: false, verbose: false };
+  Object.keys(options).forEach((key) => {
+    if (!options)
+      return { dryRun: false, quiet: false, verbose: false };
+    const value = options[key];
+    if (value === "true" || value === "false")
+      options[key] = value === "true";
+  });
+  return options;
+}
+function buddyOptions(options) {
+  if (!options) {
+    options = process3.argv.slice(2);
+    options = Array.from(new Set(options));
+    if (options[0] && !options[0].startsWith("-"))
+      options.shift();
+  }
+  if (options?.verbose) {
+    log.debug("process.argv", process3.argv);
+    log.debug("process.argv.slice(2)", process3.argv.slice(2));
+    log.debug("options inside buddyOptions", options);
+  }
+  return options.join(" ");
+}
 // src/spinner.ts
 import ora from "ora";
 var spinner = ora;
@@ -316,21 +684,25 @@ export {
   trueColorBg,
   trueColor,
   stripColors,
+  stripAnsi,
   strikethrough,
   spinner,
   runProcess,
   runCommands,
   runCommandSync,
   runCommand,
+  rightAlign,
   reset,
   red,
   prompts,
   prompt,
   parseOptions,
   parseArgv,
+  parseArgs,
   outro,
   magenta,
-  log,
+  logger,
+  log2 as log,
   link,
   lightYellow,
   lightRed,
@@ -339,6 +711,7 @@ export {
   lightGray,
   lightCyan,
   lightBlue,
+  leftAlign,
   kolorist,
   italic,
   inverse,
@@ -348,11 +721,18 @@ export {
   hidden,
   green,
   gray,
+  getColor,
   execSync,
   exec,
   dim,
   cyan,
+  command,
+  colors,
+  colorize,
   cli,
+  centerAlign,
+  buddyOptions,
+  box,
   bold,
   blue,
   black,
@@ -374,6 +754,8 @@ export {
   bgBlack,
   ansi256Bg,
   ansi256,
+  align,
   Prompt,
-  Command
+  Command,
+  CAC
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/cli",
   "type": "module",
-  "version": "0.58.58",
+  "version": "0.58.61",
   "description": "TypeScript framework for CLI artisans. Build beautiful console apps with ease.",
   "author": "Chris Breuer",
   "license": "MIT",

package/src/cli.ts

@@ -1,8 +1,7 @@
 // import type { CliOptions } from '@stacksjs/types'
-import cac from 'cac'
-import { version } from '../package.json'
+import { CAC } from 'cac'
 
-interface ParsedArgv {
+export interface ParsedArgv {
   args: ReadonlyArray<string>
   options: {
     [k: string]: any
@@ -11,8 +10,8 @@ interface ParsedArgv {
 
 interface CliOptions {
   name?: string
-  version: string
-  description: string
+  // version: string
+  // description: string
 }
 
 export function cli(name?: string | CliOptions, options?: CliOptions) {
@@ -21,32 +20,11 @@ export function cli(name?: string | CliOptions, options?: CliOptions) {
     name = options.name
   }
 
-  const cli = cac(name || 'buddy') // default to extending buddy
-
-  cli.help()
-  cli.version(options?.version || version)
-
-  return cli
+  return new CAC(name || 'buddy')
 }
 
-export function command(name: string, description: string, options?: CliOptions) {
-  return cli(options).command(name, description)
-}
-
-export function parseArgs() {
-  return cli().parse().args
-}
+export { CAC }
 
-export function parseOptions(): ParsedArgv['options'] {
-  const options = cli().parse().options
-
-  // Iterate over the options and convert "true" and "false" strings to boolean
-  for (const key in options) {
-    if (options[key] === 'true')
-      options[key] = true
-    else if (options[key] === 'false')
-      options[key] = false
-  }
-
-  return options
-}
+// export function command(name: string, description: string, options?: CliOptions) {
+//   return cli(options).command(name, description)
+// }

package/src/console.ts

@@ -1,4 +1,4 @@
-import { log } from '@stacksjs/logging'
+import { log, logger } from '@stacksjs/logging'
 import prompts from 'prompts'
 
 export class Prompt {
@@ -19,61 +19,61 @@ export class Prompt {
 
   async select(message: any, options: any) {
     if (this.isRequired())
-      return log.prompt(message, { ...options, type: 'select', required: true })
+      return logger.prompt(message, { ...options, type: 'select', required: true })
 
-    return log.prompt(message, { ...options, type: 'select' })
+    return logger.prompt(message, { ...options, type: 'select' })
   }
 
   async checkbox(message: any, options: any) {
     if (this.isRequired())
-      return log.prompt(message, { ...options, type: 'multiselect', required: true })
+      return logger.prompt(message, { ...options, type: 'multiselect', required: true })
 
-    return log.prompt(message, { ...options, type: 'multiselect' })
+    return logger.prompt(message, { ...options, type: 'multiselect' })
   }
 
   async confirm(message: any, options: any) {
     if (this.isRequired())
-      return log.prompt(message, { ...options, type: 'confirm', required: true })
+      return logger.prompt(message, { ...options, type: 'confirm', required: true })
 
-    return log.prompt(message, { ...options, type: 'confirm' })
+    return logger.prompt(message, { ...options, type: 'confirm' })
   }
 
   async input(message: any, options: any) {
     if (this.isRequired())
-      return log.prompt(message, { ...options, type: 'text', required: true })
+      return logger.prompt(message, { ...options, type: 'text', required: true })
 
-    return log.prompt(message, { ...options, type: 'text' })
+    return logger.prompt(message, { ...options, type: 'text' })
   }
 
   async password(message: any, options: any) {
     if (this.isRequired())
-      return log.prompt(message, { ...options, type: 'password', required: true })
+      return logger.prompt(message, { ...options, type: 'password', required: true })
 
-    return log.prompt(message, { ...options, type: 'password' })
+    return logger.prompt(message, { ...options, type: 'password' })
   }
 
   async number(message: any, options: any) {
     if (this.isRequired())
-      return log.prompt(message, { ...options, type: 'numeral', required: true })
+      return logger.prompt(message, { ...options, type: 'numeral', required: true })
 
-    return log.prompt(message, { ...options, type: 'numeral' })
+    return logger.prompt(message, { ...options, type: 'numeral' })
   }
 
   async multiselect(message: any, options: any) {
     if (this.isRequired())
-      return log.prompt(message, { ...options, type: 'multiselect', required: true })
+      return logger.prompt(message, { ...options, type: 'multiselect', required: true })
 
-    return log.prompt(message, { ...options, type: 'multiselect' })
+    return logger.prompt(message, { ...options, type: 'multiselect' })
   }
 
   async autocomplete(message: any, options: any) {
     if (this.isRequired())
-      return log.prompt(message, { ...options, type: 'autocomplete', required: true })
+      return logger.prompt(message, { ...options, type: 'autocomplete', required: true })
 
-    return log.prompt(message, { ...options, type: 'autocomplete' })
+    return logger.prompt(message, { ...options, type: 'autocomplete' })
   }
 }
 
-export { prompts, log }
+export { prompts, logger, log }
 
-export const prompt = new Prompt()
+export const prompt = () => new Prompt()

package/src/exec.ts

@@ -2,6 +2,7 @@ import process from 'node:process'
 import { type Result, err, handleError, ok } from '@stacksjs/error-handling'
 import type { CliOptions, StacksError, Subprocess } from '@stacksjs/types'
 import { ExitCode } from '@stacksjs/types'
+import { log } from './'
 
 /**
  * Execute a command.
@@ -24,19 +25,21 @@ import { ExitCode } from '@stacksjs/types'
  * ```
  */
 export async function exec(command: string | string[], options?: CliOptions): Promise<Result<Subprocess, StacksError>> {
-  const cmd = Array.isArray(command) ? command : command.match(/(?:[^\s"]+|"[^"]*")+/g)
+  const cmd = Array.isArray(command)
+    ? command
+    : command.match(/(?:[^\s"]+|"[^"]*")+/g)
 
   if (!cmd)
     return err(handleError(`Failed to parse command: ${cmd}`, options))
 
-  if (options?.verbose)
-    // eslint-disable-next-line no-console
-    console.log('exec', { command, cmd, options })
+  log.debug('exec:', Array.isArray(command) ? command.join(' ') : command)
+  log.debug('cmd:', cmd)
+  log.debug('exec options:', options)
 
   const proc = Bun.spawn(cmd, {
     ...options,
-    stdout: options?.silent ? 'ignore' : (options?.stdin ? options.stdin : (options?.stdout || 'inherit')),
-    stderr: options?.silent ? 'ignore' : (options?.stderr || 'inherit'),
+    stdout: (options?.silent || options?.quiet) ? 'ignore' : (options?.stdin ? options.stdin : (options?.stdout || 'inherit')),
+    stderr: (options?.silent || options?.quiet) ? 'ignore' : (options?.stderr || 'inherit'),
     detached: options?.background || false,
     cwd: options?.cwd || import.meta.dir,
     // env: { ...e, ...options?.env },
@@ -47,9 +50,12 @@ export async function exec(command: string | string[], options?: CliOptions): Pr
   })
 
   // Check if we need to write to stdin
+  // this is currently only used for `buddy aws:configure`
   if (options?.stdin === 'pipe' && options.input) {
     if (proc.stdin) {
+      // @ts-expect-error - this works even though there is a type error
       proc.stdin.write(options.input)
+      // @ts-expect-error - this works even though there is a type error
       proc.stdin.end()
     }
   }
@@ -78,10 +84,21 @@ export async function exec(command: string | string[], options?: CliOptions): Pr
  * ```
  */
 export async function execSync(command: string | string[], options?: CliOptions): Promise<string> {
-  const cmd = Array.isArray(command) ? command : command.split(' ')
+  log.debug('Running execSync:', command)
+  log.debug('execSync Options:', options)
+
+  const cmd = Array.isArray(command)
+    ? command
+    : command.match(/(?:[^\s"]+|"[^"]*")+/g)
+
+  if (!cmd) {
+    log.error(`Failed to parse command: ${cmd}`, options)
+    process.exit(ExitCode.FatalError)
+  }
+
   const proc = Bun.spawnSync(cmd, {
     ...options,
-    // stdin: 'inherit',
+    stdin: options?.stdin ?? 'inherit',
     stdout: options?.stdout ?? 'pipe',
     stderr: options?.stderr ?? 'inherit',
     cwd: options?.cwd ?? import.meta.dir,

package/src/helpers.ts

@@ -61,14 +61,14 @@ export function outro(text: string, options?: OutroOptions, error?: Error | stri
       if (error)
         log.error(`[${time.toFixed(2)}${opts.useSeconds ? 's' : 'ms'}] Failed`)
       else if (opts.type === 'info')
-        console.log(`${dim(gray(`[${time.toFixed(2)}${opts.useSeconds ? 's' : 'ms'}]`))} ${opts.message ?? 'Complete'}`)
+        log.info(`${dim(gray(`[${time.toFixed(2)}${opts.useSeconds ? 's' : 'ms'}]`))} ${opts.message ?? 'Complete'}`)
       else
-        console.log(`${dim(gray(bold(`[${time.toFixed(2)}${opts.useSeconds ? 's' : 'ms'}]`)))} ${bold(green(opts.message ?? 'Complete'))}`)
+        log.success(`${dim(gray(bold(`[${time.toFixed(2)}${opts.useSeconds ? 's' : 'ms'}]`)))} ${bold(green(opts.message ?? 'Complete'))}`)
     }
 
     else {
       if (opts?.type === 'info')
-        console.log(text)
+        log.info(text)
 
       // the following condition triggers in the case of "Cleaned up" messages
       else if (opts?.type === 'success' && opts?.quiet !== true)

package/src/index.ts

@@ -7,4 +7,4 @@ export * from './parse'
 export * from './exec'
 export * from './run'
 export * from './spinner'
-export * from './utilities'
+export * from './utils'

package/src/parse.ts

@@ -7,7 +7,10 @@ interface ParsedArgv {
   }
 }
 
-function isLongOption(arg: string): boolean {
+function isLongOption(arg?: string): boolean {
+  if (!arg)
+    return false
+
   return arg.startsWith('--')
 }
 
@@ -32,14 +35,14 @@ function parseValue(value: string): string | boolean | number {
 function parseLongOption(arg: string, argv: string[], index: number, options: { [k: string]: string | boolean | number }): number {
   const [key, value] = arg.slice(2).split('=')
   if (value !== undefined) {
-    options[key] = parseValue(value)
+    options[key as string] = parseValue(value)
   }
-  else if (index + 1 < argv.length && !argv[index + 1].startsWith('-')) {
-    options[key] = argv[index + 1]
+  else if (index + 1 < argv.length && !argv[index + 1]!.startsWith('-')) {
+    options[key as string] = argv[index + 1] as string
     index++
   }
   else {
-    options[key] = true
+    options[key as string] = true
   }
   return index
 }
@@ -47,18 +50,22 @@ function parseLongOption(arg: string, argv: string[], index: number, options: {
 function parseShortOption(arg: string, argv: string[], index: number, options: { [k: string]: string | boolean | number }): number {
   const [key, value] = arg.slice(1).split('=')
 
-  if (value !== undefined) {
+  // Check if key is undefined and handle it
+  if (key === undefined)
+    return index
+
+  if (value !== undefined && key !== undefined) {
     for (let j = 0; j < key.length; j++)
-      options[key[j]] = parseValue(value)
+      options[key[j] as string] = parseValue(value)
   }
   else {
     for (let j = 0; j < key.length; j++) {
-      if (index + 1 < argv.length && j === key.length - 1 && !argv[index + 1].startsWith('-')) {
-        options[key[j]] = parseValue(argv[index + 1])
+      if (index + 1 < argv.length && j === key.length - 1 && !argv[index + 1]!.startsWith('-')) {
+        options[key[j] as string] = parseValue(argv[index + 1]!)
         index++
       }
       else {
-        options[key[j]] = true
+        options[key[j] as string] = true
       }
     }
   }
@@ -75,6 +82,8 @@ export function parseArgv(argv?: string[]): ParsedArgv {
 
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i]
+    if (!arg)
+      continue
     if (isLongOption(arg))
       i = parseLongOption(arg, argv, i, options)
     else if (isShortOption(arg))
@@ -86,16 +95,85 @@ export function parseArgv(argv?: string[]): ParsedArgv {
   return { args, options }
 }
 
-// export function parseOptions(argv?: string[]): { [k: string]: string | boolean | number } {
-//   if (argv === undefined)
-//     argv = process.argv.slice(2)
-
-//   return parseArgv(argv).options
-// }
-
 export function parseArgs(argv?: string[]): string[] {
   if (argv === undefined)
     argv = process.argv.slice(2)
 
   return parseArgv(argv).args
 }
+
+interface CliOptions {
+  dryRun?: boolean
+  quiet?: boolean
+  verbose?: boolean
+  [k: string]: string | boolean | number | undefined
+}
+
+export function parseOptions(options?: CliOptions): CliOptions {
+  options = options || {}
+  const args = process.argv.slice(2)
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]
+    if (arg?.startsWith('--')) {
+      const key = arg.substring(2) // remove the --
+      const camelCaseKey = key.replace(
+        /-([a-z])/gi,
+        g => (g[1] ? g[1].toUpperCase() : ''), // convert kebab-case to camelCase
+      )
+
+      if (i + 1 < args.length) { // if the next arg exists
+        if (args[i + 1] === 'true' || args[i + 1] === 'false') { // if the next arg is a boolean
+          options[camelCaseKey] = args[i + 1] === 'true' // set the value to the boolean
+          i++
+        }
+        else {
+          options[camelCaseKey] = args[i + 1]
+          i++
+        }
+      }
+      else {
+        options[camelCaseKey] = true
+      }
+    }
+  }
+
+  // if options has no keys, return undefined, e.g. `buddy release`
+  if (Object.keys(options).length === 0)
+    return { dryRun: false, quiet: false, verbose: false }
+
+  // convert the string 'true' or 'false' to a boolean
+  Object.keys(options).forEach((key) => {
+    if (!options)
+      return { dryRun: false, quiet: false, verbose: false }
+
+    const value = options[key]
+
+    if (value === 'true' || value === 'false')
+      options[key] = value === 'true'
+  })
+
+  return options
+}
+// interface BuddyOptions {
+//   dryRun?: boolean
+//   verbose?: boolean
+// }
+export function buddyOptions(options?: any): string {
+  if (!options) {
+    options = process.argv.slice(2)
+    options = Array.from(new Set(options))
+    // delete the 0 element if it does not start with a -
+    // e.g. is used when buddy changelog --dry-run is used
+    if (options[0] && !options[0].startsWith('-'))
+      options.shift()
+  }
+
+  if (options?.verbose) {
+    log.debug('process.argv', process.argv)
+    log.debug('process.argv.slice(2)', process.argv.slice(2))
+    log.debug('options inside buddyOptions', options)
+  }
+
+  return options.join(' ')
+}

package/src/run.ts

@@ -1,7 +1,7 @@
 import type { CliOptions, CommandError, Subprocess } from '@stacksjs/types'
 import type { Result } from '@stacksjs/error-handling'
 import { exec, execSync } from './exec'
-import { italic, underline } from './utilities'
+import { italic } from './utils'
 import { log } from './console'
 
 /**
@@ -30,15 +30,15 @@ import { log } from './console'
  * ```
  */
 export async function runCommand(command: string, options?: CliOptions): Promise<Result<Subprocess, CommandError>> {
-  if (options?.verbose)
-    log.debug('Running command:', underline(italic(command)), 'with options:', options)
+  log.debug('runCommand:', command)
+  log.debug('options:', options)
 
   return await exec(command, options)
 }
 
 export async function runProcess(command: string, options?: CliOptions): Promise<Result<Subprocess, CommandError>> {
-  if (options?.verbose)
-    log.debug('Running command:', underline(italic(command)), 'with options:', options)
+  log.debug('runProcess:', italic(command))
+  log.debug('runProcess Options:', options)
 
   return await exec(command, options)
 }
@@ -69,8 +69,8 @@ export async function runProcess(command: string, options?: CliOptions): Promise
  * ```
  */
 export async function runCommandSync(command: string, options?: CliOptions): Promise<string> {
-  if (options?.verbose)
-    log.debug('Running command:', underline(italic(command)), 'with options:', options)
+  log.debug('runCommandSync:', italic(command))
+  log.debug('runCommandSync Options:', options)
 
   const result = await execSync(command, options)
 

package/src/utils.ts

@@ -0,0 +1,62 @@
+export * as kolorist from 'kolorist'
+
+export {
+  stripAnsi,
+  centerAlign,
+  rightAlign,
+  leftAlign,
+  align,
+  box,
+  colors,
+  getColor,
+  colorize,
+} from 'consola/utils'
+
+export {
+  ansi256Bg,
+  bgBlack,
+  bgBlue,
+  bgCyan,
+  bgGray,
+  bgGreen,
+  bgLightBlue,
+  bgLightCyan,
+  bgLightGray,
+  bgLightGreen,
+  bgLightMagenta,
+  bgLightRed,
+  bgLightYellow,
+  bgMagenta,
+  bgRed,
+  bgWhite,
+  bgYellow,
+  black,
+  blue,
+  bold,
+  cyan,
+  dim,
+  gray,
+  green,
+  hidden,
+  inverse,
+  italic,
+  lightBlue,
+  lightCyan,
+  lightGray,
+  lightGreen,
+  lightMagenta,
+  lightRed,
+  lightYellow,
+  link,
+  magenta,
+  red,
+  reset,
+  strikethrough,
+  underline,
+  white,
+  yellow,
+  ansi256,
+  trueColor,
+  trueColorBg,
+  stripColors,
+} from 'kolorist'

package/src/utilities.ts

@@ -1,2 +0,0 @@
-export * as kolorist from 'kolorist'
-export { ansi256Bg, bgBlack, bgBlue, bgCyan, bgGray, bgGreen, bgLightBlue, bgLightCyan, bgLightGray, bgLightGreen, bgLightMagenta, bgLightRed, bgLightYellow, bgMagenta, bgRed, bgWhite, bgYellow, black, blue, bold, cyan, dim, gray, green, hidden, inverse, italic, lightBlue, lightCyan, lightGray, lightGreen, lightMagenta, lightRed, lightYellow, link, magenta, red, reset, strikethrough, underline, white, yellow, ansi256, trueColor, trueColorBg, stripColors } from 'kolorist'