@stacksjs/buddy 0.53.1 → 0.56.3

package/dist/shared/buddy.4ed611cb.mjs

@@ -0,0 +1,839 @@
+import { ExitCode, Action } from '@stacksjs/types';
+import { prompt, intro, log, outro, green, bold, runCommand, cyan, italic, dim } from '@stacksjs/cli';
+import { runAction } from '@stacksjs/actions';
+import { invoke } from '@stacksjs/actions/commit';
+import { useOnline } from '@stacksjs/utils';
+import * as storage from '@stacksjs/storage';
+import { isFolder } from '@stacksjs/storage';
+import { resolve, frameworkPath, projectPath } from '@stacksjs/path';
+import { components, functions, pages, desktop } from '@stacksjs/actions/dev';
+import { componentExample, webComponentExample, invoke as invoke$1 } from '@stacksjs/actions/examples';
+import { invoke as invoke$2, types, libEntries, vueCompat, webTypes, vsCodeCustomData, ideHelpers, componentMeta, migrations } from '@stacksjs/actions/generate';
+import { invoke as invoke$3, component, database, factory, page, fx, language, createNotification, stack, createModel } from '@stacksjs/actions/make';
+import { invoke as invoke$4 } from '@stacksjs/actions/preinstall';
+import { log as log$1 } from '@stacksjs/logging';
+
+async 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",
+    pages: "Build your SSG views",
+    docs: "Build your documentation site",
+    stacks: "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.stacks, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    if (hasNoOptions$4(options)) {
+      let answers = await prompt.require().multiselect(descriptions.select, {
+        options: [
+          { label: "Components", value: "components" },
+          // { label: 'Vue Components', value: 'vue-components' },
+          // { label: 'Web Components', value: 'web-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 }), {});
+    }
+    console.log("options", options);
+    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()) {
+      log.error("Failed to build the Stacks core.", result.error);
+      process.exit();
+    }
+    outro("Stacks core built successfully", { startTime, useSeconds: true });
+  });
+  buddy.command("build:stacks", "Build the Stacks framework.").option("-s, --stacks", descriptions.stacks, { 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()) {
+      log.error("Failed to build Stacks.", result.error);
+      process.exit();
+    }
+    outro("Stacks built successfully", { startTime, useSeconds: true });
+  });
+}
+function hasNoOptions$4(options) {
+  return !options.components && !options.vueComponents && !options.webComponents && !options.elements && !options.functions && !options.pages && !options.docs && !options.stacks;
+}
+
+async 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 intro("buddy changelog");
+    const result = await runAction(Action.Changelog, options);
+    if (result.isErr()) {
+      outro("While running the changelog command, there was an issue", { ...options, startTime: perf, useSeconds: true, isError: true }, result.error);
+      process.exit();
+    }
+    outro("Generated the CHANGELOG.md file", { ...options, startTime: perf, useSeconds: true, type: "info" });
+    process.exit(ExitCode.Success);
+  });
+}
+
+async 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 intro("buddy clean");
+    const result = await runAction(Action.Clean, { ...options, verbose: true });
+    if (result.isErr()) {
+      outro("While running the clean command, there was an issue", { startTime: perf, useSeconds: true, isError: true }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    outro("Cleaned up", { startTime: perf, useSeconds: true });
+    process.exit(ExitCode.Success);
+  });
+}
+
+async 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 invoke(options);
+  });
+}
+
+async 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 intro("stacks new");
+    const name = options.name;
+    const path = resolve(process.cwd(), name);
+    await isFolderCheck(path);
+    await onlineCheck();
+    const result = await download(name, path, options);
+    if (result.isErr()) {
+      log.error(result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await ensureEnv(path, options);
+    await install(path, options);
+    if (startTime) {
+      const time = performance.now() - startTime;
+      log.success(green(`Done in ${time}ms`));
+    }
+    log.info(bold("Welcome to the Stacks Framework! \u269B\uFE0F"));
+    log.info("To learn more, visit https://stacksjs.dev");
+    process.exit(ExitCode.Success);
+  });
+}
+async function isFolderCheck(path) {
+  if (await isFolder(path)) {
+    log.error(`Path ${path} already exists`);
+    process.exit(ExitCode.FatalError);
+  }
+}
+async function onlineCheck() {
+  const online = useOnline();
+  if (!online) {
+    log.info("It appears you are disconnected from the internet.");
+    log.info("The Stacks setup requires a brief internet connection for setup.");
+    log.info("For instance, it installs your dependencies from.");
+    process.exit(ExitCode.FatalError);
+  }
+}
+async function download(name, path, options) {
+  log.info("Setting up your stack.");
+  const result = await runCommand(`giget stacks ${name}`, options);
+  log.success(`Successfully scaffolded your project at ${cyan(path)}`);
+  return result;
+}
+async function ensureEnv(path, options) {
+  log.info("Ensuring your environment is ready...");
+  await runCommand("fnm use", { ...options, cwd: path });
+  log.success("Environment is ready");
+}
+async function install(path, options) {
+  log.info("Installing & setting up Stacks");
+  let result = await runCommand("pnpm install", { ...options, cwd: path });
+  if (result.isErr()) {
+    log.error(result.error);
+    process.exit();
+  }
+  result = await runCommand("cp .env.example .env", { ...options, cwd: path });
+  if (result.isErr()) {
+    log.error(result.error);
+    process.exit(ExitCode.FatalError);
+  }
+  await runAction(Action.KeyGenerate, { ...options, cwd: path });
+  result = await runCommand("git init", { ...options, cwd: path });
+  if (result.isErr()) {
+    log.error(result.error);
+    process.exit(ExitCode.FatalError);
+  }
+  log.success("Installed & set-up \u{1F680}");
+}
+
+async function dev(buddy) {
+  const descriptions = {
+    components: "Start the Components development server",
+    desktop: "Start the Desktop development server",
+    functions: "Start the Functions development server",
+    docs: "Start the Documentation development server",
+    pages: "Start the Pages development server",
+    select: "Which development server are you trying to start?",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("dev", "Start the development server for any of the following").option("-c, --components", descriptions.components).option("-f, --functions", descriptions.functions).option("-d, --docs", descriptions.docs).option("-p, --views", descriptions.pages).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    if (hasNoOptions$3(options)) {
+      const answer = await prompt.require().select(descriptions.select, {
+        options: [
+          { value: "all", label: "All" },
+          { value: "pages", label: "Frontend" },
+          { value: "api", label: "Backend" },
+          { value: "desktop", label: "Desktop" },
+          { value: "components", label: "Components" },
+          { value: "functions", label: "Functions" },
+          { value: "docs", label: "Documentation" }
+        ]
+      });
+      if (answer === "components")
+        await components(options);
+      else if (answer === "functions")
+        await functions(options);
+      else if (answer === "pages")
+        await pages(options);
+      else
+        process.exit(ExitCode.InvalidArgument);
+    } else {
+      if (options.components)
+        await components(options);
+      else if (options.functions)
+        await functions(options);
+      else if (options.pages)
+        await pages(options);
+    }
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("dev:components", descriptions.components).action(async (options) => {
+    const perf = await intro("buddy dev:components");
+    const result = await runAction(Action.DevComponents, { ...options, verbose: true });
+    if (options.verbose)
+      log.info("runAction result is", result);
+    if (result.isErr()) {
+      outro("While running the dev:components command, there was an issue", { startTime: perf, useSeconds: true, isError: true }, result.error ?? void 0);
+      process.exit();
+    }
+    console.log("");
+    outro("Exited", { startTime: perf, useSeconds: true });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("dev:docs", descriptions.docs).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const perf = await intro("buddy dev:docs");
+    const result = await runAction(Action.DevDocs, { ...options, verbose: true });
+    if (Array.isArray(result)) ; else if (result.isErr()) {
+      outro("While running the dev:components command, there was an issue", { startTime: perf, useSeconds: true, isError: true }, result.error ?? void 0);
+      process.exit();
+    }
+    outro("Finished running dev:docs.", { startTime: perf, useSeconds: true });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("dev:desktop", descriptions.desktop).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await desktop(options);
+  });
+  buddy.command("dev:functions", descriptions.functions).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await functions(options);
+  });
+  buddy.command("dev:views", descriptions.pages).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await pages(options);
+  });
+}
+function hasNoOptions$3(options) {
+  return !options.components && !options.all && !options.docs && !options.functions && !options.pages;
+}
+
+async 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) => {
+    const answer = await prompt.require().select(descriptions.select, {
+      options: [
+        { value: "components", label: "Vue Components" },
+        { value: "web-components", label: "Web Components" }
+      ]
+    });
+    if (answer === "components")
+      await componentExample(options);
+    else if (answer === "web-components")
+      await webComponentExample(options);
+    else
+      process.exit(ExitCode.InvalidArgument);
+    await invoke$1(options);
+    process.exit(ExitCode.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 invoke$1(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 invoke$1(options);
+  });
+}
+
+async 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 intro("buddy fresh");
+    const result = await runAction(Action.Fresh, { ...options, verbose: true });
+    if (result.isErr()) {
+      outro("While running the `fresh` command, there was an issue", { startTime: perf, useSeconds: true, isError: true }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    outro("Freshly reinstalled your dependencies", { startTime: perf, useSeconds: true });
+    process.exit(ExitCode.Success);
+  });
+}
+
+async 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",
+    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("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    if (hasNoOptions$2(options)) {
+      let answers = await prompt.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 (isString(answers))
+        answers = [answers];
+      options = answers.reduce((a, v) => ({ ...a, [v]: true }), {});
+    }
+    await invoke$2(options);
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("generate:types", descriptions.types).option("--verbose", descriptions.verbose, { default: false }).alias("types:generate").action(async (options) => {
+    await types(options);
+  });
+  buddy.command("generate:entries", descriptions.entries).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await libEntries(options);
+  });
+  buddy.command("generate:vue-compatibility", descriptions.vueCompat).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await vueCompat(options);
+  });
+  buddy.command("generate:web-types", descriptions.webTypes).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await webTypes(options);
+  });
+  buddy.command("generate:vscode-custom-data", descriptions.customData).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await vsCodeCustomData(options);
+  });
+  buddy.command("generate:ide-helpers", descriptions.ideHelpers).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await ideHelpers(options);
+  });
+  buddy.command("generate:component-meta", descriptions.componentMeta).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await componentMeta(options);
+  });
+  buddy.command("generate:migrations", "Generate Migrations").action(async () => {
+    await migrations();
+  });
+}
+function hasNoOptions$2(options) {
+  return !options.types && !options.entries && !options.webTypes && !options.customData && !options.ideHelpers && !options.vueCompatibility && !options.componentMeta;
+}
+
+async 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 intro("buddy lint");
+    const result = await runAction(Action.Lint, { ...options, showSpinner: true, spinnerText: "Linting..." });
+    if (result.isErr()) {
+      outro("While running `buddy lint`, there was an issue", { startTime, useSeconds: true, isError: true }, result.error);
+      process.exit();
+    }
+    outro("Linted your project", { startTime, useSeconds: true });
+  });
+  buddy.command("lint:fix", descriptions.lintFix).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log.info("Fixing lint errors...");
+    const result = await runAction(Action.LintFix, { ...options, showSpinner: true, spinnerText: "Linting..." });
+    if (result.isErr()) {
+      log.error("There was an error lint fixing your code.", result.error);
+      process.exit();
+    }
+    log.success("Fixed lint errors");
+  });
+}
+
+async 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 intro("buddy key:generate");
+    const result = await runAction(Action.KeyGenerate, options);
+    if (result.isErr()) {
+      log.error("Failed to set random application key.", result.error);
+      process.exit();
+    }
+    outro("Set random application key.", { startTime });
+  });
+}
+
+async 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) {
+      log.error("You need to specify a name. Read more about the documentation here.");
+      process.exit();
+    }
+    if (hasNoOptions$1(options)) {
+      let answers = await prompt.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)
+        process.exit(ExitCode.InvalidArgument);
+      if (isString(answers))
+        answers = [answers];
+      options = answers.reduce((a, v) => ({ ...a, [v]: true }), {});
+    }
+    await invoke$3(options);
+    process.exit(ExitCode.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) {
+      log.error("You need to specify a name. Read more about the documentation here.");
+      process.exit();
+    }
+    await component(options);
+  });
+  buddy.command("make:database", descriptions.database).option("-n, --name", "The name of the database").option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const name = buddy.args[0] || options.name;
+    options.name = name;
+    if (!name) {
+      log.error("You need to specify a name. Read more about the documentation here.");
+      process.exit();
+    }
+    await database(options);
+  });
+  buddy.command("make:factory", descriptions.factory).option("-n, --name", "The name of the factory").option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const name = buddy.args[0] || options.name;
+    options.name = name;
+    if (!name) {
+      log.error("You need to specify a name. Read more about the documentation here.");
+      process.exit();
+    }
+    await factory(options);
+  });
+  buddy.command("make:page", descriptions.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) {
+      log.error("You need to specify a name. Read more about the documentation here.");
+      process.exit();
+    }
+    await page(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 fx(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) {
+      log.error("You need to specify a name. Read more about the documentation here.");
+      process.exit();
+    }
+    await language(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 intro("buddy make:notification");
+    const name = buddy.args[0] || options.name;
+    options.name = name;
+    if (!name) {
+      log.error("You need to specify a name. Read more about the documentation here.");
+      process.exit();
+    }
+    const result = await createNotification(options);
+    if (!result) {
+      outro("While running the make:notification command, there was an issue", { startTime: perf, useSeconds: true, isError: true });
+      process.exit();
+    }
+    outro(`Created your ${italic(name)} notification.`, { startTime: perf, useSeconds: true });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("make:stack", descriptions.stack).option("-n, --name", "The name of the stack").option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const name = buddy.args[0] || options.name;
+    options.name = name;
+    if (!name) {
+      log.error("You need to specify a name. Read more about the documentation here.");
+      process.exit();
+    }
+    await stack(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) {
+      log.error("You need to specify the model name");
+      process.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(async (options) => {
+    const path = frameworkPath("database/schema.prisma");
+    const name = buddy.args[0] || options.name;
+    options.name = name;
+    if (!name) {
+      log.error("You need to specify the migration name");
+      process.exit();
+    }
+    await runCommand(`npx prisma migrate ${options.env} --name=${name} --schema=${path}`);
+    log.success(path, name);
+  });
+}
+function hasNoOptions$1(options) {
+  return !options.component && !options.page && !options.function && !options.language && !options.database && !options.migration && !options.factory && !options.notification && !options.stack;
+}
+
+async function migrate(buddy) {
+  const descriptions = {
+    migrate: "Migrates your database",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("migrate", descriptions.migrate).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const perf = await intro("buddy migrate");
+    const result = await runAction(Action.Migrate, { ...options, showSpinner: true, spinnerText: "Migrating..." });
+    if (result.isErr()) {
+      outro("While running the migrate command, there was an issue", { startTime: perf, useSeconds: true, isError: true }, result.error);
+      process.exit();
+    }
+    const APP_ENV = process.env.APP_ENV || "local";
+    outro(`Migrated your ${APP_ENV} database.`, { startTime: perf, useSeconds: true });
+    process.exit(ExitCode.Success);
+  });
+}
+
+async 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 runAction(Action.Prepublish, options);
+  });
+}
+
+async function preinstall(buddy) {
+  const descriptions = {
+    command: "Run your preinstall script",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("preinstall", descriptions.command).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await invoke$4(options);
+  });
+}
+
+const descriptions = {
+  release: "Release a new version of your libraries/packages",
+  verbose: "Enable verbose output"
+};
+async function release(buddy) {
+  buddy.command("release", descriptions.release).option("--verbose", descriptions.verbose, { default: true }).action(async (options) => {
+    const startTime = await intro("buddy release");
+    const result = await runAction(Action.Release, { ...options, shell: true });
+    if (result.isErr()) {
+      log.error("Failed to release", result.error);
+      process.exit();
+    }
+    outro("Triggered your CI/CD release workflow", { startTime, useSeconds: true });
+  });
+}
+
+async function seed(buddy) {
+  const descriptions = {
+    seed: "Seed your database",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("seed", descriptions.seed).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const perf = await intro("buddy seed");
+    const result = await runAction(Action.Seed, { ...options, showSpinner: true, spinnerText: "Seeding..." });
+    if (result.isErr()) {
+      outro("While running the seed command, there was an issue", { startTime: perf, useSeconds: true, isError: true }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    const APP_ENV = process.env.APP_ENV || "local";
+    outro(`Seeded your ${APP_ENV} database.`, { startTime: perf, useSeconds: true });
+    process.exit(ExitCode.Success);
+  });
+}
+
+async function setup(buddy) {
+  const descriptions = {
+    ensure: "This command checks whether Node is installed. pnpm is checked via `only-allow` preinstall hook",
+    setup: "This command installs Node & pnpm",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("ensure", descriptions.ensure).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await runCommand("pnpm install", options);
+  });
+  buddy.command("setup", descriptions.setup).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await runCommand("pnpm env use", options);
+  });
+}
+
+async function test(buddy) {
+  const descriptions = {
+    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", descriptions.command).option("--ui", descriptions.ui, { default: false }).option("--verbose", descriptions.verbose, { default: true }).action(async (options) => {
+    const perf = await intro("buddy test");
+    const result = await runAction(Action.Test, { ...options, cwd: projectPath() });
+    if (result.isErr()) {
+      outro("While running `buddy test`, there was an issue", { startTime: perf, useSeconds: true, isError: true }, result.error);
+      process.exit();
+    }
+    outro("Finished running tests", { startTime: perf, useSeconds: true });
+  });
+  buddy.command("test:unit", descriptions.unit).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const perf = await intro("buddy test:unit");
+    const result = await runAction(Action.TestUnit, { ...options, verbose: true, cwd: projectPath() });
+    if (result.isErr()) {
+      outro("While running `buddy test:unit`, there was an issue", { startTime: perf, useSeconds: true, isError: true }, result.error);
+      process.exit();
+    }
+    outro("Finished running unit tests", { startTime: perf, useSeconds: true });
+  });
+  buddy.command("test:feature", descriptions.feature).option("--show-report", descriptions.showReport, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const perf = await intro("buddy test:feature");
+    let result;
+    if (options.showReport)
+      result = await runAction(Action.ShowFeatureTestReport, { ...options, verbose: true, cwd: projectPath() });
+    else
+      result = await runAction(Action.TestFeature, { ...options, verbose: true, cwd: projectPath() });
+    if (result.isErr()) {
+      outro("While running `buddy test:feature`, there was an issue", { startTime: perf, useSeconds: true, isError: true }, result.error);
+      process.exit();
+    }
+    outro("Finished running feature tests", { startTime: perf, useSeconds: true });
+  });
+  buddy.command("test:ui", descriptions.command).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const perf = await intro("buddy test:ui");
+    const result = await runAction(Action.TestUi, { ...options, verbose: true, cwd: projectPath() });
+    if (result.isErr()) {
+      outro("While running `buddy test:ui`, there was an issue", { startTime: perf, useSeconds: true, isError: true }, result.error);
+      process.exit();
+    }
+    outro("Finished running tests in the browser", { startTime: perf, useSeconds: true });
+  });
+  buddy.command("test:types", descriptions.types).alias("typecheck").option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const perf = await intro("buddy test:types");
+    const result = await runAction(Action.Typecheck, { ...options, verbose: true, cwd: projectPath() });
+    if (result.isErr()) {
+      outro("While running `buddy test:types`, there was an issue", { startTime: perf, useSeconds: true, isError: true }, result.error);
+      process.exit();
+    }
+    outro("Finished running typecheck", { startTime: perf, useSeconds: true });
+  });
+  buddy.command("test:coverage", descriptions.coverage).action(async (options) => {
+    const perf = await intro("buddy test:coverage");
+    const result = await runAction(Action.TestCoverage, { ...options, cwd: projectPath(), verbose: true });
+    if (result.isErr()) {
+      outro("While running `buddy test:coverage`, there was an issue", { startTime: perf, useSeconds: true, isError: true }, result.error);
+      process.exit();
+    }
+    outro("Generated the test coverage report", { startTime: perf, useSeconds: true });
+    process.exit();
+  });
+}
+
+async function upgrade(buddy) {
+  const descriptions = {
+    command: "Upgrade dependencies, framework, package manager, and/or Node.js",
+    framework: "Upgrade the Stacks framework",
+    dependencies: "Upgrade your dependencies",
+    packageManager: "Upgrade your package manager, i.e. pnpm",
+    node: "Upgrade Node to the version defined in ./node-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", descriptions.command).option("-c, --framework", descriptions.framework, { default: false }).option("-d, --dependencies", descriptions.dependencies, { default: false }).option("-p, --package-manager", descriptions.packageManager, { default: false }).option("-n, --node", descriptions.node, { default: false }).option("-a, --all", descriptions.all, { default: false }).option("-f, --force", descriptions.force, { default: false }).option("--verbose", descriptions.verbose, { default: false }).alias("update").example("buddy upgrade -a --verbose").action(async (options) => {
+    const perf = await intro("buddy upgrade");
+    if (hasNoOptions(options)) {
+      let answers = await prompt.require().multiselect(descriptions.select, {
+        options: [
+          { value: "dependencies", label: "Dependencies" },
+          { value: "framework", label: "Framework" },
+          { value: "node", label: "Node.js" },
+          { value: "package-manager", label: "Package Manager" }
+        ]
+      });
+      if (answers !== null)
+        process.exit(ExitCode.InvalidArgument);
+      if (isString(answers))
+        answers = [answers];
+      options = answers.reduce((a, v) => ({ ...a, [v]: true }), {});
+    }
+    const result = await runAction(Action.Upgrade, { ...options, shell: true });
+    if (result.isErr()) {
+      outro("While running the buddy:upgrade command, there was an issue", { startTime: perf, useSeconds: true, isError: true }, result.error);
+      process.exit();
+    }
+    outro("Upgrade complete.", { startTime: perf, useSeconds: true });
+    process.exit();
+  });
+  buddy.command("upgrade:framework", descriptions.framework).option("--verbose", descriptions.verbose, { default: false }).example("buddy upgrade:framework --verbose").action(async (options) => {
+    await runAction(Action.Upgrade, options);
+  });
+  buddy.command("upgrade:dependencies", descriptions.dependencies).option("--verbose", descriptions.verbose, { default: false }).alias("upgrade:deps").example("buddy upgrade:dependencies --verbose").action(async (options) => {
+    await runAction(Action.Upgrade, options);
+  });
+  buddy.command("upgrade:package-manager", descriptions.packageManager).option("--verbose", descriptions.verbose, { default: false }).alias("upgrade:pm").alias("upgrade:pnpm").example("buddy upgrade:package-manager 7.16.1 --verbose").example("buddy upgrade:package-manager latest").action(async (options) => {
+    options.version = "latest";
+    if (buddy.args[0])
+      options.version = buddy.args[0];
+    const perf = await intro("buddy upgrade:package-manager");
+    const result = await runAction(Action.UpgradePackageManager, options);
+    if (result.isErr()) {
+      outro("While running the buddy upgrade:package-manager command, there was an issue", { startTime: perf, useSeconds: true, isError: true }, result.error);
+      process.exit();
+    }
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("upgrade:node", descriptions.node).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    const perf = await intro("buddy upgrade:node");
+    const result = await runAction(Action.UpgradeNode, options);
+    if (result.isErr()) {
+      outro("While running the buddy upgrade:node command, there was an issue", { startTime: perf, useSeconds: true, isError: true }, result.error);
+      process.exit();
+    }
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("upgrade:all", descriptions.all).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    await runAction(Action.Upgrade, options);
+  });
+}
+function hasNoOptions(options) {
+  return !options.framework && !options.dependencies && !options.packageManager && !options.node && !options.all;
+}
+
+async function version(buddy) {
+  const descriptions = {
+    version: "Retrieving Stacks build version"
+  };
+  buddy.command("version", descriptions.version).action(async () => {
+    await intro("buddy version");
+    const pkg = await storage.readPackageJson("./package.json");
+    const nodeVersion = pkg.engines.node.replace(">=v", "");
+    const pnpmVersion = pkg.engines.pnpm.replace(">=", "");
+    const stacksVersion = pkg.version;
+    log$1.info(green(bold("Stacks: ")) + dim(` ${stacksVersion}`));
+    log$1.info(green(bold("node: ")) + dim(`   ${nodeVersion}`));
+    log$1.info(green(bold("pnpm: ")) + dim(`   ${pnpmVersion}`));
+  });
+}
+
+export { clean as a, build as b, changelog as c, commit as d, create as e, dev as f, example as g, fresh as h, generate as i, migrate as j, key as k, lint as l, make as m, preinstall as n, setup as o, prepublish as p, release as r, seed as s, test as t, upgrade as u, version as v };