@stacksjs/buddy 0.57.4 → 0.58.19

package/dist/chunk-815e657d8c6ba584.js

@@ -0,0 +1,1677 @@
+import {
+__require,
+__toESM
+} from "./chunk-b75e6db0012faa55.js";
+
+// src/commands/build.ts
+import process from "process";
+import {runAction} from "@stacksjs/actions";
+import {intro, log as log2, outro, prompt} from "@stacksjs/cli";
+import {ExitCode} from "@stacksjs/types";
+import {Action} from "@stacksjs/enums";
+import {isString} from "@stacksjs/validation";
+function build(buddy) {
+  const descriptions = {
+    components: "Build your component library",
+    vueComponents: "Build your Vue component library",
+    webComponents: "Build your framework agnostic web component library",
+    elements: "An alias to the -w flag",
+    functions: "Build your function library",
+    desktop: "Build the Desktop Application",
+    pages: "Build your frontend",
+    docs: "Build your documentation",
+    framework: "Build Stacks framework",
+    select: "What are you trying to build?",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("build", "Automagically build any of your libraries/packages for production use. Select any of the following packages").option("-c, --components", descriptions.components).option("-v, --vue-components", descriptions.vueComponents).option("-w, --web-components", descriptions.webComponents).option("-e, --elements", descriptions.elements).option("-f, --functions", descriptions.functions).option("-p, --views", descriptions.pages).option("-d, --docs", descriptions.docs).option("-s, --stacks", descriptions.framework, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    if (hasNoOptions(options)) {
+      let answers = await prompt.require().multiselect(descriptions.select, {
+        options: [
+          { label: "Components", value: "components" },
+          { label: "Functions", value: "functions" },
+          { label: "Pages", value: "pages" },
+          { label: "Documentation", value: "docs" }
+        ]
+      });
+      if (answers !== null)
+        process.exit(ExitCode.InvalidArgument);
+      if (isString(answers))
+        answers = [answers];
+      options = answers.reduce((a, v) => ({ ...a, [v]: true }), {});
+    }
+    await runAction(Action.BuildStacks, options);
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("build:components", "Automagically build component libraries for production use & npm/CDN distribution").option("-c, --components", descriptions.components, { default: true }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await runAction(Action.BuildComponentLibs, options);
+  });
+  buddy.command("build:cli", "Automagically build the CLI").option("-c, --components", descriptions.components, { default: true }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await runAction(Action.BuildCli, options);
+  });
+  buddy.command("build:functions", "Automagically build function library for npm/CDN distribution").option("-f, --functions", descriptions.functions, { default: true }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await runAction(Action.BuildFunctionLib, options);
+  });
+  buddy.command("build:vue-components", "Automagically build Vue component library for npm/CDN distribution").option("-v, --vue-components", descriptions.vueComponents, { default: true }).option("--verbose", descriptions.verbose, { default: false }).alias("build:vue").action(async (options) => {
+    await runAction(Action.BuildVueComponentLib, options);
+  });
+  buddy.command("build:web-components", "Automagically build Web Component library for npm/CDN distribution").option("-w, --web-components", descriptions.webComponents, { default: true }).option("--verbose", descriptions.verbose, { default: false }).alias("build:elements").alias("build:wc").action(async (options) => {
+    await runAction(Action.BuildWebComponentLib, options);
+  });
+  buddy.command("build:docs", "Automagically build your documentation site.").option("-d, --docs", descriptions.docs, { default: true }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await runAction(Action.BuildDocs, options);
+  });
+  buddy.command("build:core", "Automagically build the Stacks core.").option("--verbose", descriptions.verbose, { default: true }).action(async (options) => {
+    const startTime = await intro("buddy build:core");
+    const result = await runAction(Action.BuildCore, options);
+    if (result.isErr()) {
+      log2.error("Failed to build the Stacks core.", result.error);
+      process.exit();
+    }
+    await outro("Stacks core built successfully", { startTime, useSeconds: true });
+  });
+  buddy.command("build:desktop", descriptions.desktop).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const perf = await intro("buddy build:desktop");
+    const result = await runAction(Action.BuildDesktop, options);
+    if (result.isErr()) {
+      await outro("While running the build:desktop command, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process.exit();
+    }
+    console.log("");
+    await outro("Exited", { startTime: perf, useSeconds: true });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("build:stacks", "Build the Stacks framework.").option("-s, --stacks", descriptions.framework, { default: true }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const startTime = await intro("buddy build:stacks");
+    const result = await runAction(Action.BuildStacks, options);
+    if (result.isErr()) {
+      log2.error("Failed to build Stacks.", result.error);
+      process.exit();
+    }
+    await outro("Stacks built successfully", { startTime, useSeconds: true });
+  });
+  buddy.on("build:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process.exit(1);
+  });
+}
+var hasNoOptions = function(options) {
+  return !options.components && !options.vueComponents && !options.webComponents && !options.elements && !options.functions && !options.pages && !options.docs && !options.framework;
+};
+
+// src/commands/changelog.ts
+import process2 from "process";
+import {ExitCode as ExitCode2} from "@stacksjs/types";
+import {runAction as runAction2} from "@stacksjs/actions";
+import {intro as intro2, outro as outro2} from "@stacksjs/cli";
+import {Action as Action2} from "@stacksjs/enums";
+function changelog(buddy) {
+  const descriptions = {
+    changelog: "Create a CHANGELOG.md file",
+    quiet: "Minimal output",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("changelog", descriptions.changelog).option("--quiet", descriptions.quiet, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const perf = await intro2("buddy changelog");
+    const result = await runAction2(Action2.Changelog, options);
+    if (result.isErr()) {
+      await outro2("While running the changelog command, there was an issue", { ...options, startTime: perf, useSeconds: true }, result.error);
+      process2.exit();
+    }
+    await outro2("Generated the CHANGELOG.md file", { ...options, startTime: perf, useSeconds: true, type: "info" });
+    process2.exit(ExitCode2.Success);
+  });
+  buddy.on("changelog:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process2.exit(1);
+  });
+}
+
+// src/commands/clean.ts
+import process3 from "process";
+import {ExitCode as ExitCode3} from "@stacksjs/types";
+import {runAction as runAction3} from "@stacksjs/actions";
+import {intro as intro3, outro as outro3} from "@stacksjs/cli";
+import {Action as Action3} from "@stacksjs/enums";
+function clean(buddy) {
+  const descriptions = {
+    clean: "Removes all node_modules & lock files",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("clean", descriptions.clean).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const perf = await intro3("buddy clean");
+    const result = await runAction3(Action3.Clean, options);
+    if (result.isErr()) {
+      await outro3("While running the clean command, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process3.exit(ExitCode3.FatalError);
+    }
+    await outro3("Cleaned up", { startTime: perf, useSeconds: true, message: "Cleaned up" });
+    process3.exit(ExitCode3.Success);
+  });
+  buddy.on("clean:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process3.exit(1);
+  });
+}
+
+// src/commands/cloud.ts
+import process4 from "process";
+import {intro as intro4, italic, log as log3, outro as outro4, prompts, runCommand, runCommandSync, underline} from "@stacksjs/cli";
+import {addJumpBox, deleteCdkRemnants, deleteIamUsers, deleteJumpBox, deleteLogGroups, deleteParameterStore, deleteStacksBuckets, deleteStacksFunctions, getJumpBoxInstanceId} from "@stacksjs/cloud";
+import {path as p} from "@stacksjs/path";
+import {ExitCode as ExitCode4} from "@stacksjs/types";
+import {loop} from "@stacksjs/utils";
+function cloud2(buddy) {
+  const descriptions = {
+    cloud: "Interact with the Stacks Cloud",
+    ssh: "SSH into the Stacks Cloud",
+    add: "Add a resource to the Stacks Cloud",
+    remove: "Removes the Stacks Cloud. In case it fails, try again",
+    optimizeCost: "Removes certain resources that may be re-applied at a later time",
+    cleanUp: "Removes all resources that were retained during the cloud deletion",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("cloud", descriptions.cloud).option("--ssh", descriptions.ssh, { default: false }).option("--connect", descriptions.ssh, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    if (options.ssh || options.connect) {
+      const startTime = performance.now();
+      const jumpBoxId = await getJumpBoxInstanceId();
+      const result = await runCommand(`aws ssm start-session --target ${jumpBoxId}`, {
+        ...options,
+        cwd: p.projectPath(),
+        stdin: "pipe"
+      });
+      if (result.isErr()) {
+        await outro4("While running the cloud command, there was an issue", { startTime, useSeconds: true }, result.error);
+        process4.exit(ExitCode4.FatalError);
+      }
+      await outro4("Exited", { startTime, useSeconds: true });
+      process4.exit(ExitCode4.Success);
+    }
+    log3.info("Not implemented yet. Please use the --ssh (or --connect) flag to connect to the Stacks Cloud.");
+    process4.exit(ExitCode4.Success);
+  });
+  buddy.command("cloud:add", descriptions.add).option("--jump-box", "Remove the jump-box", { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const startTime = await intro4("buddy cloud:add");
+    if (options.jumpBox) {
+      const { confirm } = await prompts({
+        name: "confirm",
+        type: "confirm",
+        message: "Would you like to add a jump-box to your cloud?"
+      });
+      if (!confirm) {
+        await outro4("Exited", { startTime, useSeconds: true });
+        process4.exit(ExitCode4.Success);
+      }
+      log3.info("The jump-box is getting added to your cloud resources...");
+      log3.info("This takes a few moments, please be patient.");
+      await new Promise((resolve) => setTimeout(resolve, 2000));
+      const result = await addJumpBox();
+      if (result.isErr()) {
+        await outro4("While running the cloud:add command, there was an issue", { startTime, useSeconds: true }, result.error);
+        process4.exit(ExitCode4.FatalError);
+      }
+      log3.info(italic("View the jump-box in the AWS console:"));
+      log3.info(underline("https://us-east-1.console.aws.amazon.com/ec2/home?region=us-east-1#Instances:instanceState=running"));
+      log3.info(italic("Once it finished initializing, you may SSH into it:"));
+      log3.info(underline("buddy cloud --ssh"));
+      await outro4("Your jump-box was added.", { startTime, useSeconds: true });
+      process4.exit(ExitCode4.Success);
+    }
+    log3.info("This functionality is not yet implemented.");
+    process4.exit(ExitCode4.Success);
+  });
+  buddy.command("cloud:remove", descriptions.remove).alias("cloud:destroy").alias("cloud:rm").alias("undeploy").option("--jump-box", "Remove the jump-box", { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const startTime = await intro4("buddy cloud:remove");
+    if (options.jumpBox) {
+      const { confirm } = await prompts({
+        name: "confirm",
+        type: "confirm",
+        message: "Would you like to remove your jump-box for now?"
+      });
+      if (!confirm) {
+        await outro4("Exited", { startTime, useSeconds: true });
+        process4.exit(ExitCode4.Success);
+      }
+      const result2 = await deleteJumpBox();
+      if (result2.isErr()) {
+        await outro4("While removing your jump-box, there was an issue", { startTime, useSeconds: true }, result2.error);
+        process4.exit(ExitCode4.FatalError);
+      }
+      await outro4("Your jump-box was removed.", { startTime, useSeconds: true });
+      process4.exit(ExitCode4.Success);
+    }
+    console.log(`   ${italic("\u2139\uFE0F   Removing your cloud resources takes a while to complete.")}`);
+    console.log(`   ${italic("Please note, your backups will not yet be deleted. Though,")}`);
+    console.log(`   ${italic("Backups are scheduled to delete themselves in 30 days.")}`);
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+    const result = await runCommand(`bunx cdk destroy`, {
+      ...options,
+      cwd: p.cloudPath(),
+      stdin: "inherit"
+    });
+    if (result.isErr()) {
+      await outro4('While running the cloud:remove ("undeploy") command, there was an issue', { startTime, useSeconds: true }, result.error);
+      process4.exit(ExitCode4.FatalError);
+    }
+    await runCommand("buddy cloud:cleanup", {
+      ...options,
+      cwd: p.projectPath(),
+      stdin: "inherit"
+    });
+    try {
+      log3.info("Finalizing the removal of your cloud resources.");
+      log3.info("This will take a few moments...");
+      loop(7, () => {
+        runCommandSync("buddy cloud:cleanup", {
+          ...options,
+          cwd: p.projectPath(),
+          stdout: "ignore"
+        });
+      });
+      await outro4("Your cloud has been removed", { startTime, useSeconds: true });
+      process4.exit(ExitCode4.Success);
+    } catch (error) {
+      await outro4("While cleaning up the cloud, there was an issue", { startTime, useSeconds: true }, error);
+      process4.exit(ExitCode4.FatalError);
+    }
+  });
+  buddy.command("cloud:optimize-cost", descriptions.optimizeCost).option("--jump-box", "Remove the jump-box", { default: true }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const startTime = await intro4("buddy cloud:remove");
+    if (options.jumpBox) {
+      const { confirm } = await prompts({
+        name: "confirm",
+        type: "confirm",
+        message: "Would you like to remove your jump-box to optimize your costs?"
+      });
+      if (!confirm) {
+        await outro4("Exited", { startTime, useSeconds: true });
+        process4.exit(ExitCode4.Success);
+      }
+      await deleteJumpBox();
+      await outro4("Your jump-box was removed & cost optimizations are applied.", { startTime, useSeconds: true });
+      process4.exit(ExitCode4.Success);
+    }
+    await outro4("No cost optimization was applied", { startTime, useSeconds: true });
+    process4.exit(ExitCode4.Success);
+  });
+  buddy.command("cloud:cleanup", descriptions.cleanUp).alias("cloud:clean-up").option("--verbose", descriptions.verbose, { default: false }).action(async () => {
+    const startTime = await intro4("buddy cloud:cleanup");
+    log3.info(`Cleaning up your cloud resources will take a while to complete. Please be patient.`);
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+    log3.info("Removing any jump-boxes...");
+    const result = await deleteJumpBox();
+    if (result.isErr()) {
+      if (result.error !== "Jump-box not found") {
+        await outro4("While removing your jump-box, there was an issue", { startTime, useSeconds: true }, result.error);
+        process4.exit(ExitCode4.FatalError);
+      }
+    }
+    log3.info("Removing any retained S3 buckets...");
+    const result2 = await deleteStacksBuckets();
+    if (result2.isErr()) {
+      await outro4("While deleting the retained S3 buckets, there was an issue", { startTime, useSeconds: true }, result2.error);
+      process4.exit(ExitCode4.FatalError);
+    }
+    log3.info("Removing any retained Lambda functions...");
+    const result3 = await deleteStacksFunctions();
+    if (result3.isErr()) {
+      if (result3.error !== "No stacks functions found")
+        await outro4("While deleting the Origin Request Lambda function, there was an issue", { startTime, useSeconds: true }, result3.error);
+      process4.exit(ExitCode4.FatalError);
+    }
+    log3.info(result3.value);
+    log3.info("Removing any remaining Stacks logs...");
+    const result4 = await deleteLogGroups();
+    if (result4.isErr()) {
+      await outro4("While deleting the Stacks log groups, there was an issue", { startTime, useSeconds: true }, result4.error);
+      process4.exit(ExitCode4.FatalError);
+    }
+    log3.info("Removing any stored parameters...");
+    const result7 = await deleteParameterStore();
+    if (result7.isErr()) {
+      await outro4("While deleting the Stacks log groups, there was an issue", { startTime, useSeconds: true }, result7.error);
+      process4.exit(ExitCode4.FatalError);
+    }
+    log3.info("Removing any CDK remnants...");
+    const result6 = await deleteCdkRemnants();
+    if (result6.isErr()) {
+      await outro4("While deleting the Stacks log groups, there was an issue", { startTime, useSeconds: true }, result6.error);
+      process4.exit(ExitCode4.FatalError);
+    }
+    log3.info("Removing any IAM users...");
+    const result8 = await deleteIamUsers();
+    if (result8.isErr()) {
+      await outro4("While deleting the Stacks log groups, there was an issue", { startTime, useSeconds: true }, result8.error);
+      process4.exit(ExitCode4.FatalError);
+    }
+    await outro4("AWS resources have been removed", { startTime, useSeconds: true });
+    process4.exit(ExitCode4.Success);
+  });
+  buddy.on("cloud:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process4.exit(1);
+  });
+}
+
+// src/commands/commit.ts
+import process5 from "process";
+import {runCommit} from "@stacksjs/actions";
+function commit(buddy) {
+  const descriptions = {
+    commit: "Commit your stashed changes",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("commit", descriptions.commit).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await runCommit(options);
+  });
+  buddy.on("commit:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process5.exit(1);
+  });
+}
+
+// src/commands/configure.ts
+import process6 from "process";
+import {log as log4, outro as outro5, runCommand as runCommand2} from "@stacksjs/cli";
+import {path as p2} from "@stacksjs/path";
+import {config as config2} from "@stacksjs/config";
+import {ExitCode as ExitCode5} from "@stacksjs/types";
+function configure(buddy) {
+  const descriptions = {
+    configure: "Configure options",
+    aws: "Configure the AWS connection",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("configure", descriptions.configure).option("--aws", descriptions.aws, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    if (options?.aws) {
+      const startTime = performance.now();
+      const result = await runCommand2("aws configure", {
+        ...options,
+        cwd: p2.projectPath(),
+        stdin: "inherit"
+      });
+      if (result.isErr()) {
+        await outro5("While running the configure command, there was an issue", { startTime, useSeconds: true }, result.error);
+        process6.exit(ExitCode5.FatalError);
+      }
+      await outro5("Exited", { startTime, useSeconds: true });
+      process6.exit(ExitCode5.Success);
+    }
+    log4.info("Not implemented yet. Please use the --aws flag to configure AWS.");
+    process6.exit(ExitCode5.Success);
+  });
+  buddy.command("configure:aws", descriptions.aws).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const startTime = performance.now();
+    const result = await runCommand2(`aws configure --profile ${config2.app.url}`, {
+      ...options,
+      cwd: p2.cloudPath(),
+      stdin: "inherit"
+    });
+    if (result.isErr()) {
+      await outro5("While running the cloud command, there was an issue", { startTime, useSeconds: true }, result.error);
+      process6.exit(ExitCode5.FatalError);
+    }
+    await outro5("Exited", { startTime, useSeconds: true });
+    process6.exit(ExitCode5.Success);
+  });
+  buddy.on("configure:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process6.exit(ExitCode5.FatalError);
+  });
+}
+
+// src/commands/create.ts
+import process7 from "process";
+import {ExitCode as ExitCode6} from "@stacksjs/types";
+import {bold, cyan, dim, intro as intro5, log as log5, runCommand as runCommand3} from "@stacksjs/cli";
+import {useOnline} from "@stacksjs/utils";
+import {isFolder} from "@stacksjs/storage";
+import {resolve} from "@stacksjs/path";
+import {Action as Action4} from "@stacksjs/enums";
+import {runAction as runAction4} from "@stacksjs/actions";
+function create(buddy) {
+  const descriptions = {
+    command: "Create a new Stacks project",
+    ui: "Are you building a UI?",
+    components: "Are you building UI components?",
+    webComponents: "Automagically built optimized custom elements/web components?",
+    vue: "Automagically built a Vue component library?",
+    pages: "How about views/views?",
+    functions: "Are you developing functions/composables?",
+    api: "Are you building an API?",
+    database: "Do you need a database?",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("new <name>", descriptions.command).option("-u, --ui", descriptions.ui, { default: true }).option("-c, --components", descriptions.components, { default: true }).option("-w, --web-components", descriptions.webComponents, { default: true }).option("-v, --vue", descriptions.vue, { default: true }).option("-p, --views", descriptions.pages, { default: true }).option("-f, --functions", descriptions.functions, { default: true }).option("-a, --api", descriptions.api, { default: true }).option("-d, --database", descriptions.database, { default: true }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const startTime = await intro5("stacks new");
+    const name = options.name;
+    const path5 = resolve(process7.cwd(), name);
+    isFolderCheck(path5);
+    onlineCheck();
+    const result = await download(name, path5, options);
+    if (result?.isErr()) {
+      log5.error(result.error);
+      process7.exit(ExitCode6.FatalError);
+    }
+    await ensureEnv(path5, options);
+    await install(path5, options);
+    if (startTime) {
+      const time = performance.now() - startTime;
+      log5.success(dim(`[${time.toFixed(2)}ms] Completed`));
+    }
+    log5.info(bold("Welcome to the Stacks Framework! \u269B\uFE0F"));
+    log5.info("To learn more, visit https://stacksjs.org");
+    process7.exit(ExitCode6.Success);
+  });
+  buddy.on("new:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process7.exit(1);
+  });
+}
+var isFolderCheck = function(path5) {
+  if (isFolder(path5)) {
+    log5.error(`Path ${path5} already exists`);
+    process7.exit(ExitCode6.FatalError);
+  }
+};
+var onlineCheck = function() {
+  const online = useOnline();
+  if (!online) {
+    log5.info("It appears you are disconnected from the internet.");
+    log5.info("The Stacks setup requires a brief internet connection for setup.");
+    log5.info("For instance, it installs your dependencies from.");
+    process7.exit(ExitCode6.FatalError);
+  }
+};
+async function download(name, path5, options) {
+  log5.info("Setting up your stack.");
+  const result = await runCommand3(`giget stacks ${name}`, options);
+  log5.success(`Successfully scaffolded your project at ${cyan(path5)}`);
+  return result;
+}
+async function ensureEnv(path5, options) {
+  log5.info("Ensuring your environment is ready...");
+  await runCommand3("tea -SE", { ...options, cwd: path5 });
+  log5.success("Environment is ready");
+}
+async function install(path5, options) {
+  log5.info("Installing & setting up Stacks");
+  let result = await runCommand3("bun install", { ...options, cwd: path5 });
+  if (result?.isErr()) {
+    log5.error(result.error);
+    process7.exit();
+  }
+  result = await runCommand3("cp .env.example .env", { ...options, cwd: path5 });
+  if (result?.isErr()) {
+    log5.error(result.error);
+    process7.exit(ExitCode6.FatalError);
+  }
+  await runAction4(Action4.KeyGenerate, { ...options, cwd: path5 });
+  result = await runCommand3("git init", { ...options, cwd: path5 });
+  if (result.isErr()) {
+    log5.error(result.error);
+    process7.exit(ExitCode6.FatalError);
+  }
+  log5.success("Installed & set-up \uD83D\uDE80");
+}
+
+// src/commands/deploy.ts
+import process8 from "process";
+import {ExitCode as ExitCode7} from "@stacksjs/types";
+import {runAction as runAction5} from "@stacksjs/actions";
+import {intro as intro6, italic as italic2, log as log6, outro as outro6} from "@stacksjs/cli";
+import {Action as Action5} from "@stacksjs/enums";
+import {app} from "@stacksjs/config";
+import {addDomain, hasUserDomainBeenAddedToCloud} from "@stacksjs/dns";
+function deploy(buddy) {
+  const descriptions = {
+    deploy: "Reinstalls your npm dependencies",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("deploy", descriptions.deploy).option("--domain", "Specify a domain to deploy to", { default: undefined }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const startTime = await intro6("buddy deploy");
+    const domain = options.domain || app.url;
+    if (!domain) {
+      log6.info("We could not identify a domain to deploy to.");
+      log6.info("Please set your .env or ./config/app.ts properly.");
+      console.log("");
+      log6.info("Alternatively, specify a domain to deploy via the `--domain` flag.");
+      console.log("");
+      log6.info("   \u27A1\uFE0F  Example: `buddy deploy --domain example.com`");
+      console.log("");
+      process8.exit(ExitCode7.FatalError);
+    }
+    if (domain.includes("localhost")) {
+      log6.info("You are deploying to a local environment.");
+      log6.info("Please set your .env or ./config/app.ts properly.");
+      console.log("");
+      log6.info("Alternatively, specify a domain to deploy via the `--domain` flag.");
+      console.log("");
+      log6.info("   \u27A1\uFE0F  Example: `buddy deploy --domain example.com`");
+      console.log("");
+      process8.exit(ExitCode7.FatalError);
+    }
+    if (await hasUserDomainBeenAddedToCloud(domain)) {
+      log6.success("Your domain is properly configured.");
+      log6.info("Your cloud is deploying...");
+      console.log(`\u23F3 ${italic2("This may take a while...")}`);
+      await new Promise((resolve2) => setTimeout(resolve2, 2000));
+      options.domain = domain;
+    } else {
+      console.log("");
+      log6.info(`  \uD83D\uDC4B  It appears to be your first ${italic2(domain)} deployment.`);
+      console.log("");
+      log6.info(italic2("Let\u2019s ensure it is all connected properly."));
+      log6.info(italic2("One moment..."));
+      console.log("");
+      options.domain = domain;
+      const result2 = await addDomain({
+        ...options,
+        deploy: true,
+        startTime
+      });
+      if (result2.isErr()) {
+        await outro6("While running the `buddy deploy`, there was an issue", { startTime, useSeconds: true }, result2.error);
+        process8.exit(ExitCode7.FatalError);
+      }
+      await outro6("Added your domain.", { startTime, useSeconds: true });
+      process8.exit(ExitCode7.Success);
+    }
+    const result = await runAction5(Action5.Deploy, options);
+    if (result.isErr()) {
+      await outro6("While running the `buddy deploy`, there was an issue", { startTime, useSeconds: true }, result.error);
+      process8.exit(ExitCode7.FatalError);
+    }
+    await outro6("Deployment succeeded.", { startTime, useSeconds: true });
+    process8.exit(ExitCode7.Success);
+  });
+  buddy.on("deploy:*", () => {
+    log6.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process8.exit(1);
+  });
+}
+
+// src/commands/dev.ts
+import process9 from "process";
+import {Action as Action6} from "@stacksjs/enums";
+import {runAction as runAction6, runApiDevServer, runComponentsDevServer, runDocsDevServer, runFrontendDevServer} from "@stacksjs/actions";
+import {ExitCode as ExitCode8} from "@stacksjs/types";
+import {intro as intro7, log as log7, outro as outro7, prompt as prompt2, runCommand as runCommand4} from "@stacksjs/cli";
+import {sleep} from "@stacksjs/utils";
+import {libsPath} from "@stacksjs/path";
+function dev(buddy) {
+  const descriptions = {
+    dev: "Starts development server",
+    frontend: "Starts the frontend development server",
+    components: "Start the Components development server",
+    desktop: "Start the Desktop App development server",
+    dashboard: "Start the Dashboard development server",
+    api: "Start the local API development server",
+    email: "Start the Email development server",
+    docs: "Start the Documentation development server",
+    interactive: "Get asked which development server to start",
+    select: "Which development server are you trying to start?",
+    withLocalhost: "Include the localhost URL in the output",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("dev [server]", descriptions.dev).option("-f, --frontend", descriptions.frontend).option("-a, --api", descriptions.api).option("-e, --email", descriptions.email).option("-c, --components", descriptions.components).option("-d, --dashboard", descriptions.dashboard).option("-t, --desktop", descriptions.desktop).option("-d, --docs", descriptions.docs).option("-i, --interactive", descriptions.interactive, { default: false }).option("-l, --with-localhost", descriptions.withLocalhost, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (server, options) => {
+    const perf = await intro7("buddy dev");
+    await sleep(100);
+    switch (server) {
+      case "frontend":
+        await runFrontendDevServer(options);
+        break;
+      case "api":
+        await runApiDevServer(options);
+        break;
+      case "components":
+        await runComponentsDevServer(options);
+        break;
+      case "desktop":
+        await runDesktopDevServer(options);
+        break;
+      case "docs":
+        await runDocsDevServer(options);
+        break;
+      default:
+    }
+    if (wantsInteractive(options)) {
+      const answer = await prompt2.require().select(descriptions.select, {
+        options: [
+          { value: "all", label: "All" },
+          { value: "frontend", label: "Frontend" },
+          { value: "api", label: "Backend" },
+          { value: "desktop", label: "Desktop" },
+          { value: "email", label: "Email" },
+          { value: "components", label: "Components" },
+          { value: "docs", label: "Documentation" }
+        ]
+      });
+      if (answer === "components") {
+        await runComponentsDevServer(options);
+      } else if (answer === "api") {
+        await runApiDevServer(options);
+      } else if (answer === "docs") {
+        await runDocsDevServer(options);
+      } else {
+        log7.error("Invalid option during interactive mode");
+        process9.exit(ExitCode8.InvalidArgument);
+      }
+    } else {
+      if (options.components)
+        await runComponentsDevServer(options);
+      if (options.docs)
+        await runDocsDevServer(options);
+      else if (options.api)
+        await runApiDevServer(options);
+    }
+    await startDevelopmentServer(options);
+    outro7("Exited", { startTime: perf, useSeconds: true });
+    process9.exit(ExitCode8.Success);
+  });
+  buddy.command("dev:components", descriptions.components).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const perf = await intro7("buddy dev:components");
+    const result = await runCommand4("bun run dev", {
+      cwd: libsPath("components/vue")
+    });
+    if (options.verbose)
+      log7.info("buddy dev:components result", result);
+    if (result.isErr()) {
+      await outro7("While running the dev:components command, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process9.exit();
+    }
+    console.log("");
+    await outro7("Exited", { startTime: perf, useSeconds: true });
+    process9.exit(ExitCode8.Success);
+  });
+  buddy.command("dev:docs", descriptions.docs).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const perf = await intro7("buddy dev:docs");
+    const result = await runAction6(Action6.DevDocs, options);
+    if (result.isErr()) {
+      await outro7("While running the dev:docs command, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process9.exit();
+    }
+    console.log("");
+    await outro7("Exited", { startTime: perf, useSeconds: true });
+    process9.exit(ExitCode8.Success);
+  });
+  buddy.command("dev:desktop", descriptions.desktop).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const perf = await intro7("buddy dev:desktop");
+    const result = await runAction6(Action6.DevDesktop, options);
+    if (result.isErr()) {
+      await outro7("While running the dev:desktop command, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process9.exit();
+    }
+    console.log("");
+    await outro7("Exited", { startTime: perf, useSeconds: true });
+    process9.exit(ExitCode8.Success);
+  });
+  buddy.command("dev:api", descriptions.api).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await runApiDevServer(options);
+  });
+  buddy.command("dev:frontend", descriptions.frontend).alias("dev:pages").alias("dev:views").option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await runFrontendDevServer(options);
+  });
+  buddy.on("dev:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process9.exit(1);
+  });
+}
+async function startDevelopmentServer(options) {
+  const result = await runAction6(Action6.Dev, options);
+  if (result.isErr()) {
+    log7.error("While running the dev command, there was an issue", result.error);
+    process9.exit(ExitCode8.InvalidArgument);
+  }
+}
+var wantsInteractive = function(options) {
+  return options.interactive;
+};
+
+// src/commands/domains.ts
+import process10 from "process";
+import {runAction as runAction7} from "@stacksjs/actions";
+import {bgCyan, bold as bold2, intro as intro8, italic as italic3, outro as outro8, prompts as prompts2} from "@stacksjs/cli";
+import {config as config5} from "@stacksjs/config";
+import {addDomain as addDomain2} from "@stacksjs/dns";
+import {ExitCode as ExitCode9} from "@stacksjs/types";
+import {Action as Action7} from "@stacksjs/enums";
+function domains(buddy) {
+  const descriptions = {
+    purchase: "Purchase a domain",
+    add: "Add a domain to your cloud",
+    remove: "Remove a domain from your cloud",
+    skip: "Skip the confirmation prompt",
+    verbose: "Enable verbose output"
+  };
+  const c = config5.dns.contactInfo;
+  buddy.command("domains:purchase <domain>", descriptions.purchase).option("--years <years>", "Number of years to purchase the domain for", { default: 1 }).option("--privacy", "Enable privacy protection", { default: true }).option("--auto-renew", "Enable auto-renew", { default: true }).option("--first-name <firstName>", "Registrant first name", { default: c?.firstName }).option("--last-name <lastName>", "Registrant last name", { default: c?.lastName }).option("--organization <organization>", "Registrant organization name", { default: c?.organizationName }).option("--address-line1 <address>", "Registrant address line 1", { default: c?.addressLine1 }).option("--address-line2 <address>", "Registrant address line 2", { default: c?.addressLine2 }).option("--city <city>", "Registrant city", { default: c?.city }).option("--state <state>", "Registrant state", { default: c?.state }).option("--country <country>", "Registrant country code", { default: c?.countryCode }).option("--zip <zip>", "Registrant zip", { default: c?.zip }).option("--phone <phone>", "Registrant phone", { default: c?.phoneNumber }).option("--email <email>", "Registrant email", { default: c?.email }).option("--admin-first-name <firstName>", "Admin first name", { default: c?.admin?.firstName || c?.firstName }).option("--admin-last-name <lastName>", "Admin last name", { default: c?.admin?.lastName || c?.lastName }).option("--admin-organization <organization>", "Admin organization", { default: c?.admin?.organizationName || c?.organizationName }).option("--admin-address-line1 <address>", "Admin address line 1", { default: c?.admin?.addressLine1 || c?.addressLine1 }).option("--admin-address-line2 <address>", "Admin address line 2", { default: c?.admin?.addressLine2 || c?.addressLine2 }).option("--admin-city <city>", "Admin city", { default: c?.admin?.city || c?.city }).option("--admin-state <state>", "Admin state", { default: c?.admin?.state || c?.state }).option("--admin-country <country>", "Admin country code", { default: c?.admin?.countryCode || c?.countryCode }).option("--admin-zip <zip>", "Admin zip", { default: c?.admin?.zip || c?.zip }).option("--admin-phone <phone>", "Admin phone number", { default: c?.admin?.phoneNumber || c?.phoneNumber }).option("--admin-email <email>", "Admin email", { default: c?.admin?.email || c?.email }).option("--tech-first-name <firstName>", "Tech first name", { default: c?.tech?.firstName || c?.firstName }).option("--tech-last-name <lastName>", "Tech last name", { default: c?.tech?.lastName || c?.lastName }).option("--tech-organization <organization>", "Tech organization name", { default: c?.tech?.organizationName || c?.organizationName }).option("--tech-address-line1 <address>", "Tech address line 1", { default: c?.tech?.addressLine1 || c?.addressLine1 }).option("--tech-address-line2 <address>", "Tech address line 2", { default: c?.tech?.addressLine2 || c?.addressLine2 }).option("--tech-city <city>", "Tech city", { default: c?.tech?.city || c?.city }).option("--tech-state <state>", "Tech state", { default: c?.tech?.state || c?.state }).option("--tech-country <country>", "Tech country", { default: c?.tech?.countryCode || c?.countryCode }).option("--tech-zip <zip>", "Tech zip", { default: c?.tech?.zip || c?.zip }).option("--tech-phone <phone>", "Tech phone", { default: c?.tech?.phoneNumber || c?.phoneNumber }).option("--tech-email <email>", "Tech email", { default: c?.tech?.email || c?.email }).option("--privacy-admin", "Enable privacy protection for admin", { default: c?.privacyAdmin || c?.privacy || true }).option("--privacy-tech", "Enable privacy protection for tech", { default: c?.privacyTech || c?.privacy || true }).option("--privacy-registrant", "Enable privacy protection for registrant", { default: c?.privacyRegistrant || c?.privacy || true }).option("--contact-type <type>", "Contact type", { default: "person" }).option("--verbose", descriptions.verbose, { default: false }).action(async (domain, options) => {
+    options.domain = domain;
+    const startTime = await intro8("buddy domains:purchase");
+    const result = await runAction7(Action7.DomainsPurchase, options);
+    if (result.isErr()) {
+      await outro8("While running the domains:purchase command, there was an issue", { startTime, useSeconds: true }, result.error);
+      process10.exit(ExitCode9.FatalError);
+    }
+    const { confirm } = await prompts2({
+      name: "confirm",
+      type: "confirm",
+      message: `Would you like to set ${domain} as your APP_URL?`
+    });
+    if (!confirm) {
+      await outro8(`Alrighty! ${italic3(domain)} was added to your account.`, { startTime, useSeconds: true, type: "success" });
+      log.info(`Please note, you may need to validate your email address. Check your ${italic3(options.registrantEmail)} inbox.`);
+      process10.exit(ExitCode9.Success);
+    }
+    const { writeEnv } = await import("../../env/src/index.js");
+    writeEnv("APP_URL", domain);
+    let message = `Great! ${italic3(domain)} was added to your account.`;
+    message += `\n\nAnd your APP_URL has been set to ${italic3(domain)}.
+      \nPlease note, this change has not been deployed yet.
+      \nThe next time you run ${bgCyan(italic3(bold2(" buddy deploy ")))}, your app will deploy to ${italic3(domain)}.
+      \n${italic3("You may need to deploy 2-3 times for the changes to take effect. Issue tracked here: https://github.com/stacksjs/stacks/issues/685")}`;
+    await outro8(message, { startTime, useSeconds: true, type: "info" });
+    process10.exit(ExitCode9.Success);
+  });
+  buddy.command("domains:add <domain>", descriptions.add).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const startTime = await intro8("buddy domains:add");
+    const result = await addDomain2({
+      ...options,
+      startTime
+    });
+    if (result.isErr()) {
+      await outro8("While running the `buddy deploy`, there was an issue", { startTime, useSeconds: true }, result.error);
+      process10.exit(ExitCode9.FatalError);
+    }
+    await outro8("Added your domain.", { startTime, useSeconds: true });
+    process10.exit(ExitCode9.Success);
+  });
+  buddy.command("domains:remove <domain>", descriptions.remove).option("--yes", descriptions.skip, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const domain = options.domain || config5.app.url;
+    const opts = { ...options, domain };
+    const startTime = await intro8("buddy domains:remove");
+    if (!opts.yes) {
+      const { confirm } = await prompts2({
+        name: "confirm",
+        type: "confirm",
+        message: `Are you sure you want to remove ${domain}?`
+      });
+      if (!confirm) {
+        await outro8("Cancelled the domains:remove command", { startTime, useSeconds: true, type: "info" });
+        process10.exit(ExitCode9.Success);
+      }
+    }
+    const result = await runAction7(Action7.DomainsRemove, opts);
+    if (result.isErr()) {
+      await outro8("While running the domains:remove command, there was an issue", { startTime, useSeconds: true }, result.error);
+      process10.exit(ExitCode9.FatalError);
+    }
+    await outro8("Removed your domain DNS records.", { startTime, useSeconds: true });
+    process10.exit(ExitCode9.Success);
+  });
+  buddy.on("domains:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process10.exit(1);
+  });
+}
+
+// src/commands/dns.ts
+import process11 from "process";
+import {ExitCode as ExitCode10} from "@stacksjs/types";
+import {config as config7} from "@stacksjs/config";
+import {runCommand as runCommand5} from "@stacksjs/cli";
+function dns3(buddy) {
+  const descriptions = {
+    dns: "Lists the DNS records for a domain",
+    query: "Host name or IP address to query",
+    type: "Type of the DNS record being queried (A, MX, NS\u2026)",
+    nameserver: "Address of the nameserver to send packets to",
+    class: "Network class of the DNS record being queried (IN, CH, HS)",
+    udp: "Use the DNS protocol over UDP",
+    tcp: "Use the DNS protocol over TCP",
+    tls: "Use the DNS-over-TLS protocol",
+    https: "Use the DNS-over-HTTPS protocol",
+    short: "Short mode: display nothing but the first result",
+    json: "Display the output as JSON",
+    pretty: "Display the output as JSON in a pretty format",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("dns [domain]", descriptions.dns).option("-q, --query <query>", descriptions.query).option("-t, --type <type>", descriptions.type, { default: "ANY" }).option("-n, --nameserver <nameserver>", descriptions.nameserver).option("--class <class>", descriptions.nameserver).option("-U, --udp", descriptions.udp).option("-T, --tcp", descriptions.tcp).option("-S, --tls", descriptions.tls).option("-H, --https", descriptions.https).option("-1, --short", descriptions.short, { default: false }).option("-J, --json", descriptions.json, { default: false }).option("-p, --pretty", descriptions.pretty, { default: true }).option("--verbose", descriptions.verbose, { default: false }).action(async (domain, options) => {
+    delete options.pretty;
+    delete options.p;
+    const optionsString = Object.entries(options).filter(([key, value]) => key !== "--" && key.length > 1 && value !== false).map(([key, value]) => `--${key} ${value}`).join(" ");
+    await runCommand5(`dog ${domain || config7.app.url} ${optionsString}`);
+    process11.exit(ExitCode10.Success);
+  });
+}
+
+// src/commands/example.ts
+import process12 from "process";
+import {ExitCode as ExitCode11} from "@stacksjs/types";
+import {runExample} from "@stacksjs/actions";
+function example(buddy) {
+  const descriptions = {
+    example: "Which example do you want to see?",
+    components: "Test your libraries against your built bundle",
+    vue: "Test your Vue component library",
+    webComponents: "Test your web component library",
+    select: "Which example are you trying to view?",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("example", descriptions.example).option("-c, --components", descriptions.components).option("-v, --vue", descriptions.vue).option("-w, --web-components", descriptions.webComponents).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await runExample(options);
+    process12.exit(ExitCode11.Success);
+  });
+  buddy.command("example:vue", descriptions.vue).option("-v, --vue", descriptions.verbose, { default: true }).option("--verbose", descriptions.verbose, { default: false }).alias("example:components").action(async (options) => {
+    await runExample(options);
+  });
+  buddy.command("example:web-components", "Test your Web Component library.").option("-w, --web-components", descriptions.verbose, { default: true }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await runExample(options);
+  });
+  buddy.on("example:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process12.exit(1);
+  });
+}
+
+// src/commands/fresh.ts
+import process13 from "process";
+import {ExitCode as ExitCode12} from "@stacksjs/types";
+import {runAction as runAction8} from "@stacksjs/actions";
+import {intro as intro9, outro as outro9} from "@stacksjs/cli";
+import {Action as Action8} from "@stacksjs/enums";
+function fresh(buddy) {
+  const descriptions = {
+    fresh: "Reinstalls your npm dependencies",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("fresh", descriptions.fresh).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const perf = await intro9("buddy fresh");
+    const result = await runAction8(Action8.Fresh, { ...options, stdout: "inherit" });
+    if (result.isErr()) {
+      await outro9("While running `buddy fresh`, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process13.exit(ExitCode12.FatalError);
+    }
+    await outro9("Freshly reinstalled your dependencies", { startTime: perf, useSeconds: true });
+    process13.exit(ExitCode12.Success);
+  });
+  buddy.on("fresh:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process13.exit(1);
+  });
+}
+
+// src/commands/generate.ts
+import process14 from "process";
+import {
+generateComponentMeta,
+generateIdeHelpers,
+generateLibEntries,
+generateMigrations,
+generatePkgxConfig,
+generateTypes,
+generateVsCodeCustomData,
+generateVueCompat,
+generateWebTypes,
+invoke as startGenerationProcess
+} from "@stacksjs/actions";
+import {prompt as prompt3} from "@stacksjs/cli";
+import {ExitCode as ExitCode13} from "@stacksjs/types";
+import {isString as isString2} from "@stacksjs/validation";
+function generate(buddy) {
+  const descriptions = {
+    command: "Automagically build any of your libraries/packages for production use. Select any of the following packages",
+    types: "Generate your TypeScript types",
+    entries: "Generate your function & component library entry points",
+    webTypes: "Generate web-types.json for IDEs",
+    customData: "Generate VS Code custom data (custom-elements.json) for IDEs",
+    ideHelpers: "Generate IDE helpers",
+    vueCompat: "Generate Vue 2 & 3 compatibility",
+    componentMeta: "Generate component meta information",
+    tea: "Generate the Tea configuration file",
+    select: "What are you trying to generate?",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("generate", descriptions.command).option("-t, --types", descriptions.types).option("-e, --entries", descriptions.entries).option("-w, --web-types", descriptions.webTypes).option("-c, --custom-data", descriptions.customData).option("-i, --ide-helpers", descriptions.ideHelpers).option("-v, --vue-compatibility", descriptions.vueCompat).option("-c, --component-meta", descriptions.componentMeta).option("-tc, --tea-config", descriptions.tea).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    if (hasNoOptions2(options)) {
+      let answers = await prompt3.require().multiselect(descriptions.select, {
+        options: [
+          { label: "1.) TypeScript Types", value: "types" },
+          { label: "2.) Library Entry Points", value: "entries" },
+          { label: "3.) Web Types", value: "web-types" },
+          { label: "4.) VS Code Custom Data", value: "custom-data" },
+          { label: "5.) IDE Helpers", value: "ide-helpers" },
+          { label: "6.) Vue 2 & 3 Compatibility", value: "vue-compatibility" },
+          { label: "7.) Component Meta", value: "component-meta" }
+        ]
+      });
+      if (isString2(answers))
+        answers = [answers];
+      options = answers.reduce((a, v) => ({ ...a, [v]: true }), {});
+    }
+    await startGenerationProcess(options);
+    process14.exit(ExitCode13.Success);
+  });
+  buddy.command("generate:types", descriptions.types).option("--verbose", descriptions.verbose, { default: false }).alias("types:generate").action(async (options) => {
+    await generateTypes(options);
+  });
+  buddy.command("generate:entries", descriptions.entries).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await generateLibEntries(options);
+  });
+  buddy.command("generate:vue-compatibility", descriptions.vueCompat).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await generateVueCompat(options);
+  });
+  buddy.command("generate:web-types", descriptions.webTypes).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await generateWebTypes(options);
+  });
+  buddy.command("generate:vscode-custom-data", descriptions.customData).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await generateVsCodeCustomData(options);
+  });
+  buddy.command("generate:ide-helpers", descriptions.ideHelpers).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await generateIdeHelpers(options);
+  });
+  buddy.command("generate:component-meta", descriptions.componentMeta).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await generateComponentMeta(options);
+  });
+  buddy.command("generate:tea-config", descriptions.tea).option("--verbose", descriptions.verbose, { default: false }).action(() => {
+    generatePkgxConfig();
+  });
+  buddy.command("generate:migrations", "Generate Migrations").action(() => {
+    generateMigrations();
+  });
+  buddy.on("generate:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process14.exit(1);
+  });
+}
+var hasNoOptions2 = function(options) {
+  return !options.types && !options.entries && !options.webTypes && !options.customData && !options.ideHelpers && !options.vueCompatibility && !options.componentMeta;
+};
+
+// src/commands/http.ts
+import process15 from "process";
+import {ExitCode as ExitCode14} from "@stacksjs/types";
+import {config as config9} from "@stacksjs/config";
+import {runCommandSync as runCommandSync2} from "@stacksjs/cli";
+function http(buddy) {
+  const descriptions = {
+    http: "Send an HTTP request to a domain",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("http [domain]", descriptions.http).action(async (domain, options) => {
+    const optionsString = Object.entries(options).filter(([key, value]) => key !== "--" && key.length > 1 && value !== false).map(([key, value]) => `--${key} ${value}`).join(" ");
+    const command = `http GET ${domain || config9.app.url} ${optionsString}`;
+    console.log(`Running command: ${command}`);
+    runCommandSync2(command);
+    process15.exit(ExitCode14.Success);
+  });
+}
+
+// src/commands/lint.ts
+import process16 from "process";
+import {intro as intro10, log as log8, outro as outro10} from "@stacksjs/cli";
+import {Action as Action9} from "@stacksjs/enums";
+import {runAction as runAction9} from "@stacksjs/actions";
+function lint(buddy) {
+  const descriptions = {
+    lint: "Automagically lints your project codebase",
+    lintFix: "Automagically fixes all lint errors",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("lint", descriptions.lint).option("-f, --fix", descriptions.lintFix, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const startTime = await intro10("buddy lint");
+    const result = await runAction9(Action9.Lint, { ...options });
+    if (result.isErr()) {
+      await outro10("While running `buddy lint`, there was an issue", { startTime, useSeconds: true }, result.error);
+      process16.exit();
+    }
+    await outro10("Linted your project", { startTime, useSeconds: true });
+  });
+  buddy.command("lint:fix", descriptions.lintFix).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log8.info("Fixing lint errors...");
+    const result = await runAction9(Action9.LintFix, { ...options });
+    if (result.isErr()) {
+      log8.error("There was an error lint fixing your code.", result.error);
+      process16.exit();
+    }
+    log8.success("Fixed lint errors");
+  });
+  buddy.on("lint:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process16.exit(1);
+  });
+}
+
+// src/commands/inspire.ts
+import process17 from "process";
+import {ExitCode as ExitCode15} from "@stacksjs/types";
+import {runAction as runAction10} from "@stacksjs/actions";
+import {intro as intro11, outro as outro11} from "@stacksjs/cli";
+import {Action as Action10} from "@stacksjs/enums";
+function inspire(buddy) {
+  buddy.command("inspire", "Inspire yourself with a random quote").option("--two", "Show two quotes", { default: false }).action(async () => {
+    const perf = await intro11("buddy inspire");
+    const result = await runAction10(Action10.Inspire);
+    if (result.isErr()) {
+      await outro11("While running the inspire command, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process17.exit();
+    }
+    await outro11("Your quote is: ...", { startTime: perf, useSeconds: true });
+    process17.exit(ExitCode15.Success);
+  });
+}
+
+// src/commands/install.ts
+import process18 from "process";
+import {runCommand as runCommand6} from "@stacksjs/cli";
+import {path as p3} from "@stacksjs/path";
+function install2(buddy) {
+  const descriptions = {
+    install: "Install your dependencies",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("install", descriptions.install).option("-v, --verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await runCommand6("bun install", {
+      ...options,
+      cwd: p3.projectPath()
+    });
+  });
+  buddy.on("install:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process18.exit(1);
+  });
+}
+
+// src/commands/key.ts
+import process19 from "process";
+import {intro as intro12, log as log9, outro as outro12} from "@stacksjs/cli";
+import {Action as Action11} from "@stacksjs/enums";
+import {runAction as runAction11} from "@stacksjs/actions";
+function key(buddy) {
+  const descriptions = {
+    command: "Generate & set the application key.",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("key:generate", descriptions.command).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const startTime = await intro12("buddy key:generate");
+    const result = await runAction11(Action11.KeyGenerate, options);
+    if (result.isErr()) {
+      log9.error("Failed to set random application key.", result.error);
+      process19.exit();
+    }
+    await outro12("Random application key set.", { startTime });
+  });
+  buddy.on("key:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process19.exit(1);
+  });
+}
+
+// src/commands/make.ts
+import process20 from "process";
+import {
+createModel,
+createNotification,
+invoke,
+makeComponent,
+makeDatabase,
+makeFunction,
+makeLanguage,
+makePage,
+makeStack
+} from "@stacksjs/actions";
+import {intro as intro13, italic as italic4, outro as outro13, prompt as prompt4} from "@stacksjs/cli";
+import {log as log10} from "@stacksjs/logging";
+import {ExitCode as ExitCode16} from "@stacksjs/types";
+import {isString as isString3} from "@stacksjs/validation";
+function make(buddy) {
+  const descriptions = {
+    model: "Create a new model",
+    component: "Create a new component",
+    page: "Create a new page",
+    function: "Create a new function",
+    language: "Create a new language",
+    database: "Create a new database",
+    migration: "Create a new migration",
+    factory: "Create a new factory",
+    notification: "Create a new notification",
+    stack: "Create a new new stack",
+    select: "What are you trying to make?",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("make", "The make command").option("-c, --component", descriptions.component, { default: false }).option("-p, --page", descriptions.page, { default: false }).option("-f, --function", descriptions.function, { default: false }).option("-l, --language", descriptions.language, { default: false }).option("-d, --database", descriptions.database, { default: false }).option("-m, --migration", descriptions.migration, { default: false }).option("-f, --factory", descriptions.factory, { default: false }).option("-n, --notification", descriptions.notification, { default: false }).option("-s, --stack", descriptions.stack, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const name = buddy.args[0];
+    if (!name) {
+      log10.error("You need to specify a name. Read more about the documentation here.");
+      process20.exit();
+    }
+    if (hasNoOptions3(options)) {
+      let answers = await prompt4.require().multiselect(descriptions.select, {
+        options: [
+          { label: "Page", value: "page" },
+          { label: "Function", value: "function" },
+          { label: "Component", value: "component" },
+          { label: "Notification", value: "notification" },
+          { label: "Language", value: "language" },
+          { label: "Database", value: "database" },
+          { label: "Migration", value: "migration" },
+          { label: "Factory", value: "factory" },
+          { label: "Stack", value: "stack" }
+        ]
+      });
+      if (answers !== null)
+        process20.exit(ExitCode16.InvalidArgument);
+      if (isString3(answers))
+        answers = [answers];
+      options = answers.reduce((a, v) => ({ ...a, [v]: true }), {});
+    }
+    await invoke(options);
+    process20.exit(ExitCode16.Success);
+  });
+  buddy.command("make:component", descriptions.component).option("-n, --name", "The name of the component").option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const name = buddy.args[0] || options.name;
+    options.name = name;
+    if (!name) {
+      log10.error("You need to specify a name. Read more about the documentation here.");
+      process20.exit();
+    }
+    await makeComponent(options);
+  });
+  buddy.command("make:database", descriptions.database).option("-n, --name", "The name of the database").option("--verbose", descriptions.verbose, { default: false }).action((options) => {
+    const name = buddy.args[0] || options.name;
+    options.name = name;
+    if (!name) {
+      log10.error("You need to specify a name. Read more about the documentation here.");
+      process20.exit();
+    }
+    makeDatabase(options);
+  });
+  buddy.command("make:factory", descriptions.factory).option("-n, --name", "The name of the factory").option("--verbose", descriptions.verbose, { default: false }).action((options) => {
+    const name = buddy.args[0] || options.name;
+    options.name = name;
+    if (!name) {
+      log10.error("You need to specify a name. Read more about the documentation here.");
+      process20.exit();
+    }
+  });
+  buddy.command("make:view", descriptions.page).alias("make:page").option("-n, --name", "The name of the page").option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const name = buddy.args[0] || options.name;
+    options.name = name;
+    if (!name) {
+      log10.error("You need to specify a name. Read more about the documentation here.");
+      process20.exit();
+    }
+    await makePage(options);
+  });
+  buddy.command("make:function", descriptions.function).option("-n, --name", "The name of the function").option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await makeFunction(options);
+  });
+  buddy.command("make:lang", descriptions.language).option("-n, --name", "The name of the language").option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const name = buddy.args[0] || options.name;
+    options.name = name;
+    if (!name) {
+      log10.error("You need to specify a name. Read more about the documentation here.");
+      process20.exit();
+    }
+    await makeLanguage(options);
+  });
+  buddy.command("make:notification", descriptions.notification).option("-n, --name", "The name of the notification").option("-e, --email", "Is it an email notification?", { default: true }).option("-c, --chat", "Is it a chat notification?", { default: false }).option("-s, --sms", "Is it a SMS notification?", { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const perf = await intro13("buddy make:notification");
+    const name = buddy.args[0] || options.name;
+    options.name = name;
+    if (!name) {
+      log10.error("You need to specify a name. Read more about the documentation here.");
+      process20.exit();
+    }
+    const result = await createNotification(options);
+    if (!result) {
+      await outro13("While running the make:notification command, there was an issue", { startTime: perf, useSeconds: true });
+      process20.exit();
+    }
+    await outro13(`Created your ${italic4(name)} notification.`, { startTime: perf, useSeconds: true });
+    process20.exit(ExitCode16.Success);
+  });
+  buddy.command("make:stack", descriptions.stack).option("-n, --name", "The name of the stack").option("--verbose", descriptions.verbose, { default: false }).action((options) => {
+    const name = buddy.args[0] || options.name;
+    options.name = name;
+    if (!name) {
+      log10.error("You need to specify a name. Read more about the documentation here.");
+      process20.exit();
+    }
+    makeStack(options);
+  });
+  buddy.command("make:model", descriptions.model).option("-n, --name", "The name of the model").action(async (options) => {
+    const name = buddy.args[0] || options.name;
+    options.name = name;
+    if (!name) {
+      log10.error("You need to specify a model name");
+      process20.exit();
+    }
+    await createModel(options);
+  });
+  buddy.command("make:migration", descriptions.migration).option("-n, --name", "The name of the migration").option("-e, --env", "The environment to run the migration in", { default: "dev" }).action((options) => {
+    const name = buddy.args[0] || options.name;
+    options.name = name;
+    if (!name) {
+      log10.error("You need to specify a migration name");
+      process20.exit();
+    }
+    log10.info(path, name);
+  });
+  buddy.on("make:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process20.exit(1);
+  });
+}
+var hasNoOptions3 = function(options) {
+  return !options.component && !options.page && !options.function && !options.language && !options.database && !options.migration && !options.factory && !options.notification && !options.stack;
+};
+
+// src/commands/migrate.ts
+import process21 from "process";
+import {ExitCode as ExitCode17} from "@stacksjs/types";
+import {runAction as runAction12} from "@stacksjs/actions";
+import {intro as intro14, outro as outro14} from "@stacksjs/cli";
+import {Action as Action12} from "@stacksjs/enums";
+function migrate(buddy) {
+  const descriptions = {
+    migrate: "Migrates your database",
+    dns: "Writes the DNS records for a domain to ./config/dns.ts",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("migrate", descriptions.migrate).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const perf = await intro14("buddy migrate");
+    const result = await runAction12(Action12.Migrate, { ...options });
+    if (result.isErr()) {
+      await outro14("While running the migrate command, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process21.exit();
+    }
+    const APP_ENV = process21.env.APP_ENV || "local";
+    await outro14(`Migrated your ${APP_ENV} database.`, { startTime: perf, useSeconds: true });
+    process21.exit(ExitCode17.Success);
+  });
+  buddy.command("migrate:dns", descriptions.migrate).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const perf = await intro14("buddy migrate");
+    const result = await runAction12(Action12.MigrateDns, { ...options });
+    if (result.isErr()) {
+      await outro14("While running the migrate:dns command, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process21.exit();
+    }
+    const APP_URL = process21.env.APP_URL || "undefined";
+    await outro14(`Migrated your ${APP_URL} DNS.`, { startTime: perf, useSeconds: true });
+    process21.exit(ExitCode17.Success);
+  });
+  buddy.on("migrate:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process21.exit(1);
+  });
+}
+
+// src/commands/prepublish.ts
+import process22 from "process";
+import {Action as Action13} from "@stacksjs/enums";
+import {runAction as runAction13} from "@stacksjs/actions";
+function prepublish(buddy) {
+  const descriptions = {
+    command: "Run your prepublish script",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("prepublish", descriptions.command).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await runAction13(Action13.Prepublish, options);
+  });
+  buddy.on("prepublish:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process22.exit(1);
+  });
+}
+
+// src/commands/release.ts
+import process23 from "process";
+import {Action as Action14} from "@stacksjs/enums";
+import {ExitCode as ExitCode18} from "@stacksjs/types";
+import {intro as intro15, log as log11, outro as outro15} from "@stacksjs/cli";
+import {runAction as runAction14} from "@stacksjs/actions";
+function release(buddy) {
+  buddy.command("release", descriptions.release).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const startTime = await intro15("buddy release");
+    const result = await runAction14(Action14.Release, { ...options, stdin: "inherit" });
+    if (result.isErr()) {
+      log11.error("Failed to release", result.error);
+      process23.exit(ExitCode18.FatalError);
+    }
+    await outro15("Triggered your CI/CD release workflow", { startTime, useSeconds: true });
+  });
+  buddy.on("release:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process23.exit(1);
+  });
+}
+var descriptions = {
+  release: "Release a new version of your libraries/packages",
+  verbose: "Enable verbose output"
+};
+
+// src/commands/seed.ts
+import process24 from "process";
+import {ExitCode as ExitCode19} from "@stacksjs/types";
+import {runAction as runAction15} from "@stacksjs/actions";
+import {intro as intro16, outro as outro16} from "@stacksjs/cli";
+import {Action as Action15} from "@stacksjs/enums";
+function seed(buddy) {
+  const descriptions2 = {
+    seed: "Seed your database",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("seed", descriptions2.seed).option("--verbose", descriptions2.verbose, { default: false }).action(async (options) => {
+    const perf = await intro16("buddy seed");
+    const result = await runAction15(Action15.Seed, options);
+    if (result.isErr()) {
+      await outro16("While running the seed command, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process24.exit(ExitCode19.FatalError);
+    }
+    const APP_ENV = process24.env.APP_ENV || "local";
+    await outro16(`Seeded your ${APP_ENV} database.`, { startTime: perf, useSeconds: true });
+    process24.exit(ExitCode19.Success);
+  });
+  buddy.on("seed:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process24.exit(1);
+  });
+}
+
+// src/commands/setup.ts
+import process25 from "process";
+import {path as p4} from "@stacksjs/path";
+import {handleError} from "@stacksjs/error-handling";
+import {log as log12, runCommand as runCommand7} from "@stacksjs/cli";
+import {ExitCode as ExitCode20} from "@stacksjs/types";
+function setup(buddy) {
+  const descriptions2 = {
+    ensure: "This command ensures your project is setup correctly",
+    setup: "This command sets up your project for the first time",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("setup", descriptions2.setup).alias("ensure").option("--verbose", descriptions2.verbose, { default: false }).action(async (options) => {
+    if (await ensurePkgxIsInstalled())
+      await optimizePkgxDeps();
+    else
+      await installPkgx();
+    await initializeProject(options);
+  });
+  buddy.on("setup:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process25.exit(ExitCode20.FatalError);
+  });
+}
+async function ensurePkgxIsInstalled() {
+  const result = await runCommand7("pkgx --version", { silent: true });
+  if (result.isOk())
+    return true;
+  return false;
+}
+async function installPkgx() {
+  const result = await runCommand7("./scripts/setup");
+  if (result.isOk())
+    return;
+  handleError(result.error);
+  process25.exit(ExitCode20.FatalError);
+}
+async function initializeProject(options) {
+  log12.info("\u23F3 Installing node_modules...");
+  await new Promise((resolve2) => setTimeout(resolve2, 1500));
+  const result = await runCommand7("bun install", {
+    cwd: options.cwd || p4.projectPath()
+  });
+  if (result.isErr()) {
+    handleError(result.error);
+    process25.exit(ExitCode20.FatalError);
+  }
+  log12.success("Installed node_modules");
+  log12.info("\u23F3 Ensuring .env exists...");
+  const envResult = await runCommand7("cp .env.example .env", {
+    cwd: options.cwd || p4.projectPath()
+  });
+  if (envResult.isErr()) {
+    handleError(envResult.error);
+    process25.exit(ExitCode20.FatalError);
+  }
+  log12.success(".env exists");
+  log12.info("\u23F3 Generating application key...");
+  const keyResult = await runCommand7("buddy key:generate", {
+    cwd: options.cwd || p4.projectPath()
+  });
+  if (keyResult.isErr()) {
+    handleError(keyResult.error);
+    process25.exit(ExitCode20.FatalError);
+  }
+  log12.success("Generated application key");
+  log12.info("\u23F3 Ensuring AWS is connected...");
+  const awsResult = await runCommand7("buddy configure:aws", {
+    cwd: options.cwd || p4.projectPath()
+  });
+  if (awsResult.isErr()) {
+    handleError(awsResult.error);
+    process25.exit(ExitCode20.FatalError);
+  }
+  log12.success("Configured AWS");
+  await new Promise((resolve2) => setTimeout(resolve2, 300));
+  log12.success("Project is setup");
+  await new Promise((resolve2) => setTimeout(resolve2, 300));
+  log12.info("\uD83C\uDF89 Happy coding!");
+}
+async function optimizePkgxDeps() {
+  return new Promise((resolve2) => setTimeout(resolve2, 300));
+}
+
+// src/commands/test.ts
+import process26 from "process";
+import {runAction as runAction16} from "@stacksjs/actions";
+import {intro as intro17, outro as outro17} from "@stacksjs/cli";
+import {projectPath} from "@stacksjs/path";
+import {Action as Action16} from "@stacksjs/enums";
+function test(buddy) {
+  const descriptions2 = {
+    command: "Runs your test suite",
+    types: "Typechecks your codebase",
+    coverage: "Generates a test coverage report",
+    ui: "Runs your test suite in the browser",
+    unit: "Runs your unit tests",
+    feature: "Runs your feature tests",
+    showReport: "Show the test report",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("test", descriptions2.command).option("--ui", descriptions2.ui, { default: false }).option("--verbose", descriptions2.verbose, { default: true }).action(async (options) => {
+    const perf = await intro17("buddy test");
+    const result = await runAction16(Action16.Test, { ...options, cwd: projectPath() });
+    if (result.isErr()) {
+      await outro17("While running `buddy test`, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process26.exit();
+    }
+    await outro17("Finished running tests", { startTime: perf, useSeconds: true });
+  });
+  buddy.command("test:unit", descriptions2.unit).option("--verbose", descriptions2.verbose, { default: false }).action(async (options) => {
+    const perf = await intro17("buddy test:unit");
+    const result = await runAction16(Action16.TestUnit, { ...options, verbose: true, cwd: projectPath() });
+    if (result.isErr()) {
+      await outro17("While running `buddy test:unit`, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process26.exit();
+    }
+    await outro17("Finished running unit tests", { startTime: perf, useSeconds: true });
+  });
+  buddy.command("test:feature", descriptions2.feature).option("--show-report", descriptions2.showReport, { default: false }).option("--verbose", descriptions2.verbose, { default: false }).action(async (options) => {
+    const perf = await intro17("buddy test:feature");
+    let result;
+    if (options.showReport)
+      result = await runAction16(Action16.ShowFeatureTestReport, { ...options, verbose: true, cwd: projectPath() });
+    else
+      result = await runAction16(Action16.TestFeature, { ...options, verbose: true, cwd: projectPath() });
+    if (result.isErr()) {
+      await outro17("While running `buddy test:feature`, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process26.exit();
+    }
+    await outro17("Finished running feature tests", { startTime: perf, useSeconds: true });
+  });
+  buddy.command("test:ui", descriptions2.command).option("--verbose", descriptions2.verbose, { default: false }).action(async (options) => {
+    const perf = await intro17("buddy test:ui");
+    const result = await runAction16(Action16.TestUi, { ...options, verbose: true, cwd: projectPath() });
+    if (result.isErr()) {
+      await outro17("While running `buddy test:ui`, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process26.exit();
+    }
+    await outro17("Finished running tests in the browser", { startTime: perf, useSeconds: true });
+  });
+  buddy.command("test:types", descriptions2.types).alias("typecheck").option("--verbose", descriptions2.verbose, { default: false }).action(async (options) => {
+    const perf = await intro17("buddy test:types");
+    const result = await runAction16(Action16.Typecheck, { ...options, verbose: true, cwd: projectPath() });
+    if (result.isErr()) {
+      await outro17("While running `buddy test:types`, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process26.exit();
+    }
+    await outro17("Finished running typecheck", { startTime: perf, useSeconds: true });
+  });
+  buddy.command("test:coverage", descriptions2.coverage).action(async (options) => {
+    const perf = await intro17("buddy test:coverage");
+    const result = await runAction16(Action16.TestCoverage, { ...options, cwd: projectPath(), verbose: true });
+    if (result.isErr()) {
+      await outro17("While running `buddy test:coverage`, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process26.exit();
+    }
+    await outro17("Generated the test coverage report", { startTime: perf, useSeconds: true });
+    process26.exit();
+  });
+  buddy.on("test:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process26.exit(1);
+  });
+}
+
+// src/commands/tinker.ts
+import process27 from "process";
+import {ExitCode as ExitCode21} from "@stacksjs/types";
+import {runAction as runAction17} from "@stacksjs/actions";
+import {intro as intro18, outro as outro18} from "@stacksjs/cli";
+import {Action as Action17} from "@stacksjs/enums";
+function tinker(buddy) {
+  const descriptions2 = {
+    tinker: "Tinker with your code",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("tinker", descriptions2.tinker).option("--verbose", descriptions2.verbose, { default: false }).action(async (options) => {
+    const perf = await intro18("buddy tinker");
+    const result = await runAction17(Action17.Tinker, options);
+    if (result.isErr()) {
+      await outro18("While running the tinker command, there was an issue", { startTime: perf, useSeconds: true }, result.error || undefined);
+      process27.exit();
+    }
+    await outro18("Tinker mode exited.", { startTime: perf, useSeconds: true });
+    process27.exit(ExitCode21.Success);
+  });
+  buddy.on("tinker:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process27.exit(1);
+  });
+}
+
+// src/commands/types.ts
+import process28 from "process";
+import {generateTypes as generateTypes2} from "@stacksjs/actions";
+function types22(buddy) {
+  const descriptions2 = {
+    generate: "Generate the types of & for your library/libraries",
+    fix: "wip",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("types:generate", descriptions2.generate).option("--verbose", descriptions2.verbose, { default: false }).action(async () => {
+    await generateTypes2();
+  });
+  buddy.command("types:fix", descriptions2.fix).option("--verbose", descriptions2.verbose, { default: false }).action(async () => {
+  });
+  buddy.on("types:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process28.exit(1);
+  });
+}
+
+// src/commands/upgrade.ts
+import process29 from "process";
+import {runAction as runAction18} from "@stacksjs/actions";
+import {intro as intro19, outro as outro19, prompt as prompt5} from "@stacksjs/cli";
+import {ExitCode as ExitCode22} from "@stacksjs/types";
+import {Action as Action18} from "@stacksjs/enums";
+import {isString as isString4} from "@stacksjs/validation";
+function upgrade(buddy) {
+  const descriptions2 = {
+    command: "Upgrade dependencies, framework, package manager, JS/TS runtime",
+    framework: "Upgrade the Stacks framework",
+    dependencies: "Upgrade your dependencies",
+    bun: "Upgrade Bun to the latest version",
+    all: "Upgrade Node, package manager, project dependencies, and framework",
+    force: "Overwrite possible local updates with remote framework updates",
+    select: "What are you trying to upgrade?",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("upgrade", descriptions2.command).option("-c, --framework", descriptions2.framework, { default: false }).option("-d, --dependencies", descriptions2.dependencies, { default: false }).option("-b, --bun", descriptions2.bun, { default: false }).option("-a, --all", descriptions2.all, { default: false }).option("-f, --force", descriptions2.force, { default: false }).option("--verbose", descriptions2.verbose, { default: false }).alias("update").example("buddy upgrade -a --verbose").action(async (options) => {
+    const perf = await intro19("buddy upgrade");
+    if (hasNoOptions4(options)) {
+      let answers = await prompt5.require().multiselect(descriptions2.select, {
+        options: [
+          { value: "dependencies", label: "Dependencies" },
+          { value: "framework", label: "Framework" },
+          { value: "node", label: "Node.js" },
+          { value: "package-manager", label: "Package Manager" }
+        ]
+      });
+      if (answers !== null)
+        process29.exit(ExitCode22.InvalidArgument);
+      if (isString4(answers))
+        answers = [answers];
+      options = answers.reduce((a, v) => ({ ...a, [v]: true }), {});
+    }
+    const result = await runAction18(Action18.Upgrade, { ...options });
+    if (result.isErr()) {
+      await outro19("While running the buddy:upgrade command, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process29.exit();
+    }
+    await outro19("Upgrade complete.", { startTime: perf, useSeconds: true });
+    process29.exit();
+  });
+  buddy.command("upgrade:framework", descriptions2.framework).option("--verbose", descriptions2.verbose, { default: false }).example("buddy upgrade:framework --verbose").action(async (options) => {
+    await runAction18(Action18.Upgrade, options);
+  });
+  buddy.command("upgrade:dependencies", descriptions2.dependencies).option("--verbose", descriptions2.verbose, { default: false }).alias("upgrade:deps").example("buddy upgrade:dependencies --verbose").action(async (options) => {
+    await runAction18(Action18.Upgrade, options);
+  });
+  buddy.command("upgrade:bun", descriptions2.bun).option("--verbose", descriptions2.verbose, { default: false }).action(async (options) => {
+    const perf = await intro19("buddy upgrade:bun");
+    const result = await runAction18(Action18.UpgradeBun, options);
+    if (result.isErr()) {
+      await outro19("While running the buddy upgrade:bun command, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process29.exit();
+    }
+    process29.exit(ExitCode22.Success);
+  });
+  buddy.command("upgrade:all", descriptions2.all).option("--verbose", descriptions2.verbose, { default: false }).action(async (options) => {
+    await runAction18(Action18.Upgrade, options);
+  });
+}
+var hasNoOptions4 = function(options) {
+  return !options.framework && !options.dependencies && !options.packageManager && !options.node && !options.all;
+};
+
+// src/commands/version.ts
+import {bold as bold3, dim as dim2, green, intro as intro20, log as log13} from "@stacksjs/cli";
+import {storage as storage3} from "@stacksjs/storage";
+function version(buddy) {
+  const descriptions2 = {
+    version: "Retrieving Stacks build version"
+  };
+  buddy.command("version", descriptions2.version).action(async () => {
+    await intro20("buddy version");
+    const pkg = await storage3.readPackageJson("./package.json");
+    const bunVersion = "wip";
+    const stacksVersion = pkg.version;
+    log13.info(green(bold3("@stacksjs/ ")) + dim2(` ${stacksVersion}`));
+    log13.info(green(bold3("Bun: ")) + dim2(`   ${bunVersion}`));
+  });
+}
+export { build, changelog, clean, cloud2 as cloud, commit, configure, create, deploy, dev, startDevelopmentServer, domains, dns3 as dns, example, fresh, generate, http, lint, inspire, install2 as install, key, make, migrate, prepublish, release, seed, setup, optimizePkgxDeps, test, tinker, types22 as types, upgrade, version };