@stacksjs/buddy 0.70.88 → 0.70.90

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -0,0 +1,165 @@
+#!/usr/bin/env bun
+import process from "node:process";
+import { cli, log } from "@stacksjs/cli";
+import { path as p } from "@stacksjs/path";
+const args = process.argv.slice(2), requestedCommand = args[0] || "help", isHelpFlag = args.includes("--help") || args.includes("-h"), isVersionOnly = ["--version", "-v", "version"].includes(requestedCommand), isHelpMode = requestedCommand === "help" || isHelpFlag && args.length <= 2, skipAppKeyCheck = [
+  "build",
+  "lint",
+  "lint:fix",
+  "test",
+  "test:types",
+  "test:unit",
+  "test:feature",
+  "typecheck",
+  "types:fix",
+  "types:generate",
+  "clean",
+  "fresh",
+  "about",
+  "doctor",
+  "setup",
+  "setup:ssl",
+  "setup:oh-my-zsh",
+  "deploy",
+  "serve",
+  "new",
+  "create",
+  "migrate",
+  "seed",
+  "generate",
+  "make",
+  "key:generate",
+  "scaffold:crud"
+].some((cmd) => requestedCommand === cmd || requestedCommand.startsWith(`${cmd}:`)) || isHelpFlag || isHelpMode, needsFullSetup = !isVersionOnly;
+if (needsFullSetup) {
+  const reportFatal = (label, error) => {
+    log.debug(`Buddy ${label}`);
+    try {
+      process.stderr.write(`
+[buddy] ${label}: ${error?.stack ?? String(error)}
+`);
+    } catch {}
+    log.error(error);
+    return process.exit(1);
+  };
+  process.on("uncaughtException", (error) => reportFatal("uncaughtException", error));
+  process.on("unhandledRejection", (error) => reportFatal("unhandledRejection", error));
+}
+async function main() {
+  const buddy = cli("buddy"), configPath = "./buddy.config.js";
+  try {
+    await Bun.file(configPath).text();
+    const { applyBuddyConfig } = await import("./config.js");
+    await applyBuddyConfig(buddy);
+  } catch {}
+  if (needsFullSetup) {
+    const { loadCommands, getCommandsToLoad, markLoaded } = await import("./lazy-commands.js"), { setup } = await import("./commands/setup.js");
+    setup(buddy);
+    markLoaded(buddy, "setup");
+    if (!skipAppKeyCheck) {
+      const { runAction } = await import("@stacksjs/actions"), { Action } = await import("@stacksjs/enums"), { ensureProjectIsInitialized } = await import("@stacksjs/utils");
+      if (!await ensureProjectIsInitialized()) {
+        log.info("Your `APP_KEY` is not yet set");
+        log.info("Generating application key...");
+        const result = await runAction(Action.KeyGenerate);
+        if (result.isErr) {
+          log.error("Failed to set random application key.", result.error);
+          process.exit(1);
+        }
+      }
+    }
+    const commandsToLoad = getCommandsToLoad(args);
+    await loadCommands(commandsToLoad, buddy);
+    await dynamicImports(buddy);
+  } else {
+    const { loadCommand } = await import("./lazy-commands.js");
+    await loadCommand("version", buddy);
+  }
+  buddy.help();
+  if (args.length === 0 && process.stdin.isTTY && !buddy.isNoInteraction)
+    await showInteractiveMenu(buddy);
+  else
+    buddy.parse();
+}
+async function showInteractiveMenu(buddy) {
+  const { bold, green, intro } = await import("@stacksjs/cli"), { select } = await import("@stacksjs/cli");
+  await intro("buddy");
+  console.log(bold(green("What would you like to do?")));
+  console.log("");
+  const choice = await select({
+    message: "Select a command:",
+    choices: [
+      { value: "dev", label: "Start development server" },
+      { value: "build", label: "Build for production" },
+      { value: "test", label: "Run tests" },
+      { value: "list", label: "List all commands" },
+      { value: "doctor", label: "Run health checks" },
+      { value: "about", label: "Show system information" },
+      { value: "help", label: "Show help" },
+      { value: "exit", label: "Exit" }
+    ],
+    initial: 0
+  });
+  console.log("");
+  if (choice === "exit")
+    process.exit(0);
+  else if (choice === "help")
+    buddy.outputHelp();
+  else {
+    process.argv = ["bun", "buddy", choice];
+    buddy.parse();
+  }
+}
+await main();
+async function dynamicImports(buddy) {
+  const { fs } = await import("@stacksjs/storage"), commandsDir = p.appPath("Commands");
+  try {
+    const registry = (await import(p.appPath("Commands.ts"))).default || {};
+    for (const [signature, config] of Object.entries(registry)) {
+      const commandConfig = typeof config === "string" ? { file: config, enabled: !0 } : config;
+      if (commandConfig.enabled === !1)
+        continue;
+      const commandPath = `${commandsDir}/${commandConfig.file}.ts`;
+      if (!fs.existsSync(commandPath)) {
+        log.debug(`Command file not found: ${commandPath} (registered as '${signature}')`);
+        continue;
+      }
+      try {
+        const dynamicImport = await import(commandPath);
+        if (typeof dynamicImport.default === "function") {
+          dynamicImport.default(buddy);
+          if (commandConfig.aliases && Array.isArray(commandConfig.aliases))
+            for (const alias of commandConfig.aliases)
+              buddy.alias(signature, alias);
+        } else
+          log.error(`Expected a default export function in ${commandConfig.file}.ts, but got:`, dynamicImport.default);
+      } catch (error) {
+        log.error(`Failed to load command ${commandConfig.file}:`, error);
+      }
+    }
+  } catch {
+    if (!fs.existsSync(commandsDir)) {
+      log.debug("app/Commands directory not found, skipping user commands");
+      return;
+    }
+    log.debug("Commands.ts not found, using auto-discovery");
+    const commandFiles = fs.readdirSync(commandsDir).filter((file) => file.endsWith(".ts"));
+    for (const file of commandFiles) {
+      const commandPath = `${commandsDir}/${file}`;
+      try {
+        const dynamicImport = await import(commandPath);
+        if (typeof dynamicImport.default === "function")
+          dynamicImport.default(buddy);
+        else
+          log.debug(`Skipping ${file} \u2014 no default export function`);
+      } catch (error) {
+        log.error(`Failed to load command ${file}:`, error);
+      }
+    }
+  }
+  try {
+    const listenerImport = await import(p.listenersPath("Console.ts"));
+    if (typeof listenerImport.default === "function")
+      listenerImport.default(buddy);
+  } catch {}
+}

package/dist/commands/about.d.ts

@@ -0,0 +1,2 @@
+import type { CLI } from '@stacksjs/types';
+export declare function about(buddy: CLI): void;

package/dist/commands/about.js

@@ -0,0 +1,35 @@
+import process from "node:process";
+import { bold, dim, green, intro, log, onUnknownSubcommand } from "@stacksjs/cli";
+import { storage } from "@stacksjs/storage";
+export function about(buddy) {
+  buddy.command("about", "Display diagnostic information about Stacks").action(async () => {
+    log.debug("Running `buddy about` ...");
+    await intro("buddy about");
+    try {
+      const stacksVersion = (await storage.readPackageJson("./package.json")).version || "unknown", bunVersion = process.versions.bun || "N/A", nodeVersion = process.versions.node || "N/A", os = process.platform, arch = process.arch, osVersion = process.version, env = process.env.NODE_ENV || process.env.APP_ENV || "development";
+      log.info("");
+      log.info(green(bold("Stacks Framework")));
+      log.info(dim("\u2500".repeat(50)));
+      log.info("");
+      log.info(bold("Version Information:"));
+      log.info(`  Stacks:  ${dim(stacksVersion)}`);
+      log.info(`  Bun:     ${dim(bunVersion)}`);
+      if (nodeVersion !== "N/A")
+        log.info(`  Node:    ${dim(nodeVersion)}`);
+      log.info("");
+      log.info(bold("Environment:"));
+      log.info(`  Mode:    ${dim(env)}`);
+      log.info(`  OS:      ${dim(`${os} ${arch}`)}`);
+      log.info(`  Runtime: ${dim(osVersion)}`);
+      log.info("");
+      log.info(bold("Configuration:"));
+      log.info(`  Cache:   ${dim("file")}`);
+      log.info(`  Debug:   ${dim(process.env.DEBUG ? "enabled" : "disabled")}`);
+      log.info("");
+    } catch (error) {
+      log.error("Failed to retrieve system information:", error);
+      process.exit(1);
+    }
+  });
+  onUnknownSubcommand(buddy, "about");
+}

package/dist/commands/add.d.ts

@@ -0,0 +1,2 @@
+import type { CLI } from '@stacksjs/types';
+export declare function add(buddy: CLI): void;

package/dist/commands/add.js

@@ -0,0 +1,33 @@
+import process from "node:process";
+import { runAdd } from "@stacksjs/actions";
+import { log } from "@stacksjs/logging";
+import { ExitCode } from "@stacksjs/types";
+import { onUnknownSubcommand } from "@stacksjs/cli";
+export function add(buddy) {
+  const descriptions = {
+    add: "Add a stack to your project (coming soon)",
+    table: "Add the Table Stack to your project",
+    calendar: "Add the Calendar Stack to your project",
+    all: "Add all stacks",
+    select: "Which stack/s are you trying to add?",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("add", descriptions.add).option("-t, --table", descriptions.table, { default: !1 }).option("-c, --calendar", descriptions.calendar, { default: !1 }).option("-a, --all", descriptions.all, { default: !1 }).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy add`...", options);
+    if (hasNoOptions(options))
+      ;
+    await runAdd(options);
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("add:table", descriptions.table).option("-t, --table", descriptions.table, { default: !0 }).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    await runAdd(options);
+  });
+  buddy.command("add:calendar", descriptions.calendar).option("-t, --calendar", descriptions.calendar, { default: !0 }).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    await runAdd(options);
+  });
+  onUnknownSubcommand(buddy, "add");
+}
+function hasNoOptions(options) {
+  return !options.all && !options.table && !options.calendar;
+}

package/dist/commands/auth.d.ts

@@ -0,0 +1,2 @@
+import type { CLI } from '@stacksjs/types';
+export declare function auth(buddy: CLI): void;

package/dist/commands/auth.js

@@ -0,0 +1,68 @@
+import process from "node:process";
+import { runAction } from "@stacksjs/actions";
+import { intro, log, onUnknownSubcommand, outro } from "@stacksjs/cli";
+import { Action } from "@stacksjs/enums";
+import { ExitCode } from "@stacksjs/types";
+export function auth(buddy) {
+  const descriptions = {
+    setup: "Set up authentication (migrations + personal access client)",
+    token: "Create a personal access client token",
+    client: "Create a new OAuth client",
+    prune: "Prune expired and revoked tokens",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("auth:setup", descriptions.setup).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy auth:setup` ...", options);
+    const perf = await intro("buddy auth:setup"), result = await runAction(Action.AuthSetup, options);
+    if (result.isErr) {
+      await outro("While setting up authentication, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Authentication setup completed successfully.", {
+      startTime: perf,
+      useSeconds: !0
+    });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("auth:token", descriptions.token).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy auth:token` ...", options);
+    const perf = await intro("buddy auth:token"), result = await runAction(Action.CreatePersonalAccessClient, options);
+    if (result.isErr) {
+      await outro("While creating the personal access client token, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Personal access client token created successfully.", {
+      startTime: perf,
+      useSeconds: !0
+    });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("auth:client", descriptions.client).option("-n, --name [name]", "Client name", { default: "OAuth Client" }).option("-r, --redirect [redirect]", "Redirect URI", { default: "http://localhost" }).option("--personal", "Create a personal access client", { default: !1 }).option("--password", "Create a password grant client", { default: !1 }).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy auth:client` ...", options);
+    const perf = await intro("buddy auth:client"), result = await runAction(Action.AuthClient, options);
+    if (result.isErr) {
+      await outro("While creating the OAuth client, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("OAuth client created successfully.", {
+      startTime: perf,
+      useSeconds: !0
+    });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("auth:prune", descriptions.prune).option("--expired", "Prune expired tokens (default: true)", { default: !0 }).option("--revoked", "Prune revoked tokens (default: true)", { default: !0 }).option("-d, --days [days]", "Prune revoked tokens older than N days", { default: 7 }).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy auth:prune` ...", options);
+    const perf = await intro("buddy auth:prune"), result = await runAction(Action.AuthPrune, options);
+    if (result.isErr) {
+      await outro("While pruning tokens, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Token pruning completed successfully.", {
+      startTime: perf,
+      useSeconds: !0
+    });
+    process.exit(ExitCode.Success);
+  });
+  onUnknownSubcommand(buddy, "auth");
+}

package/dist/commands/build.d.ts

@@ -0,0 +1,2 @@
+import type { CLI } from '@stacksjs/types';
+export declare function build(buddy: CLI): void;

package/dist/commands/build.js

@@ -0,0 +1,153 @@
+import process from "node:process";
+import { intro, log, onUnknownSubcommand, outro } from "@stacksjs/cli";
+import { Action } from "@stacksjs/enums";
+import { ExitCode } from "@stacksjs/types";
+let _runAction;
+async function runAction(...args) {
+  if (!_runAction)
+    _runAction = (await import("@stacksjs/actions")).runAction;
+  return _runAction(...args);
+}
+export function build(buddy) {
+  const descriptions = {
+    build: "Build any of your libraries (packages) for production use",
+    components: "Build your component library",
+    webComponents: "Build your framework agnostic web component library",
+    elements: "An alias to the -w flag",
+    buddy: "Build the Buddy binary",
+    functions: "Build your function library",
+    desktop: "Build the Desktop Application",
+    pages: "Build your frontend",
+    docs: "Build your documentation",
+    framework: "Build Stacks framework",
+    cli: "Automagically build the CLI",
+    server: "Build the Stacks cloud server (Docker image)",
+    frontendStatic: "Build the prerendered marketing/public static site (storage/framework/frontend-dist)",
+    select: "What are you trying to build?",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("build [type]", descriptions.build).option("-c, --components", descriptions.components).option("-w, --web-components", descriptions.webComponents).option("-e, --elements", descriptions.elements).option("-f, --functions", descriptions.functions).option("-p, --views", descriptions.pages).option("--pages", descriptions.pages).option("-d, --docs", descriptions.docs).option("-b, --buddy", descriptions.buddy, { default: !1 }).option("-s, --stacks", descriptions.framework, { default: !1 }).option("--project [project]", descriptions.project, { default: !1 }).option("--server", descriptions.server, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (server, options) => {
+    log.debug("Running `buddy build` ...", options);
+    switch (server) {
+      case "components":
+        options.components = !0;
+        break;
+      case "web-components":
+        options.webComponents = !0;
+        break;
+      case "functions":
+        options.functions = !0;
+        break;
+      case "views":
+        options.views = !0;
+        break;
+      case "docs":
+        options.docs = !0;
+        break;
+      case "buddy":
+        options.buddy = !0;
+        break;
+      case "cli":
+        options.buddy = !0;
+        break;
+      case "stacks":
+        options.stacks = !0;
+        break;
+      case "server":
+        options.server = !0;
+        break;
+      default:
+        break;
+    }
+    if (hasNoOptions(options))
+      options.stacks = !0;
+    if (options.docs)
+      await runAction(Action.BuildDocs);
+    if (options.components)
+      await runAction(Action.BuildComponentLibs);
+    if (options.webComponents)
+      await runAction(Action.BuildWebComponentLib);
+    if (options.functions)
+      await runAction(Action.BuildFunctionLib);
+    if (options.views)
+      await runAction(Action.BuildViews);
+    if (options.stacks)
+      await runAction(Action.BuildStacks);
+    if (options.buddy)
+      await runAction(Action.BuildCli);
+    if (options.server)
+      await runAction(Action.BuildServer);
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("build:components", "Automagically build component libraries for production use & npm/CDN distribution").alias("prod:components").option("-c, --components", descriptions.components, { default: !0 }).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy build:components` ...", options);
+    await runAction(Action.BuildComponentLibs, options);
+  });
+  buddy.command("build:cli", descriptions.cli).alias("prod:cli").option("-b, --buddy", descriptions.buddy, { default: !0 }).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy build:cli` ...", options);
+    await runAction(Action.BuildCli, options);
+  });
+  buddy.command("build:server", descriptions.server).alias("prod:server").alias("build:docker").option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy build:server` ...", options);
+    await runAction(Action.BuildServer, options);
+  });
+  buddy.command("build:functions", "Automagically build function library for npm/CDN distribution").option("-f, --functions", descriptions.functions, { default: !0 }).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy build:functions` ...", options);
+    await runAction(Action.BuildFunctionLib, options);
+  });
+  buddy.command("build:web-components", "Automagically build Web Component library for npm/CDN distribution").alias("build:wc").alias("prod:web-components").alias("prod:wc").option("-w, --web-components", descriptions.webComponents, {
+    default: !0
+  }).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy build:web-components` ...", options);
+    await runAction(Action.BuildWebComponentLib, options);
+  });
+  buddy.command("build:frontend", descriptions.pages).alias("build:pages").alias("build:views").alias("prod:frontend").option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy build:frontend` ...", options);
+    await runAction(Action.BuildViews, options);
+  });
+  buddy.command("build:docs", "Automagically build your documentation site.").alias("prod:docs").alias("build:documentation").alias("prod:documentation").option("-d, --docs", descriptions.docs, { default: !0 }).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy build:docs` ...", options);
+    await runAction(Action.BuildDocs, options);
+  });
+  buddy.command("build:frontend-static", descriptions.frontendStatic).alias("build:public").alias("prod:frontend-static").option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy build:frontend-static` ...", options);
+    await runAction(Action.BuildFrontendStatic, options);
+  });
+  buddy.command("build:core", "Automagically build the Stacks core.").option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy build:core` ...", options);
+    const startTime = await intro("buddy build:core"), result = await runAction(Action.BuildCore, options);
+    if (result.isErr) {
+      log.error("Failed to build the Stacks core.", result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Core packages built successfully", {
+      startTime,
+      useSeconds: !0
+    });
+  });
+  buddy.command("build:desktop", descriptions.desktop).alias("prod:desktop").option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy build:desktop` ...", options);
+    const perf = await intro("buddy build:desktop"), result = await runAction(Action.BuildDesktop, options);
+    if (result.isErr) {
+      await outro("While running the build:desktop command, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    console.log("");
+    await outro("Exited", { startTime: perf, useSeconds: !0 });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("build:stacks", "Build the Stacks framework.").option("-s, --stacks", descriptions.framework, { default: !0 }).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy build:stacks` ...", options);
+    const startTime = await intro("buddy build:stacks"), result = await runAction(Action.BuildStacks, options);
+    if (result.isErr) {
+      log.error("Failed to build Stacks.", result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Stacks built successfully", { startTime, useSeconds: !0 });
+  });
+  onUnknownSubcommand(buddy, "build");
+}
+function hasNoOptions(options) {
+  return !options.components && !options.webComponents && !options.elements && !options.functions && !options.views && !options.docs && !options.stacks && !options.buddy && !options.server;
+}

package/dist/commands/cd.d.ts

@@ -0,0 +1,20 @@
+import type { CLI } from '@stacksjs/types';
+/**
+ * `buddy cd <name>` — resolve the absolute path of a Stacks project by name.
+ *
+ * A child process can't mutate its parent shell's cwd, so this command
+ * prints the resolved path to stdout rather than calling `chdir()`. Users
+ * who want true `cd` behavior add a shell wrapper to their rc:
+ *
+ *   bcd() { eval "$(buddy cd "$1" --eval)"; }
+ *
+ * Then `bcd my-project` actually changes the shell's directory.
+ *
+ * The underlying scan (`findStacksProjects`) excludes `~/Documents`,
+ * `~/Library`, `~/Pictures`, `~/.Trash` by default. Users with projects
+ * outside `~/` can point the scan at a specific root via `--root <dir>`
+ * or the `STACKS_PROJECTS_ROOT` env var.
+ *
+ * stacksjs/stacks#527.
+ */
+export declare function cd(buddy: CLI): void;

package/dist/commands/cd.js

@@ -0,0 +1,39 @@
+import { basename } from "node:path";
+import process from "node:process";
+import { ExitCode } from "@stacksjs/types";
+import { findStacksProjects } from "@stacksjs/utils";
+export function cd(buddy) {
+  buddy.command("cd [name]", "Print the absolute path of a Stacks project by name").option("--eval", 'Emit `cd "path"` instead of just the path \u2014 pair with `eval "$(buddy cd <name> --eval)"` for real shell-cd', { default: !1 }).option("--root <dir>", "Search root for the project scan (overrides STACKS_PROJECTS_ROOT and the home-dir default)").option("--verbose", "Enable verbose output", { default: !1 }).action(async (name, options) => {
+    if (!name) {
+      process.stderr.write(`Usage: buddy cd <project-name> [--eval] [--root <dir>]
+`);
+      process.stderr.write('Tip: add `bcd() { eval "$(buddy cd "$1" --eval)"; }` to your shell rc to make this act like a real `cd`.\n');
+      process.exit(ExitCode.FatalError);
+    }
+    const root = options.root ?? process.env.STACKS_PROJECTS_ROOT ?? void 0, projects = await findStacksProjects(root, { quiet: !0 }), needle = name.toLowerCase(), exact = projects.filter((p) => basename(p).toLowerCase() === needle), matches = exact.length > 0 ? exact : projects.filter((p) => basename(p).toLowerCase().includes(needle));
+    if (matches.length === 0) {
+      process.stderr.write(`No Stacks project matched: ${name}
+`);
+      if (!root)
+        process.stderr.write(`(Scanned home dir, excluding ~/Documents, ~/Library, ~/Pictures, ~/.Trash. Set STACKS_PROJECTS_ROOT or pass --root <dir> to scan elsewhere.)
+`);
+      process.exit(ExitCode.FatalError);
+    }
+    if (matches.length > 1) {
+      process.stderr.write(`Ambiguous project name "${name}". Matches:
+`);
+      for (const m of matches)
+        process.stderr.write(`  - ${basename(m)}  \u2192  ${m}
+`);
+      process.exit(ExitCode.FatalError);
+    }
+    const dest = matches[0];
+    if (options.eval)
+      process.stdout.write(`cd ${JSON.stringify(dest)}
+`);
+    else
+      process.stdout.write(`${dest}
+`);
+    process.exit(ExitCode.Success);
+  });
+}

package/dist/commands/changelog.d.ts

@@ -0,0 +1,2 @@
+import type { CLI } from '@stacksjs/types';
+export declare function changelog(buddy: CLI): void;

package/dist/commands/changelog.js

@@ -0,0 +1,32 @@
+import process from "node:process";
+import { runAction } from "@stacksjs/actions";
+import { intro, log, onUnknownSubcommand, outro } from "@stacksjs/cli";
+import { Action } from "@stacksjs/enums";
+import { ExitCode } from "@stacksjs/types";
+export function changelog(buddy) {
+  const descriptions = {
+    changelog: "Create a CHANGELOG.md file",
+    quiet: "Minimal output",
+    dryRun: "Do not write the file, just output the changes",
+    from: "Start git revision for generated changelog",
+    project: "Target a specific project",
+    to: "End git revision for generated changelog",
+    verbose: "Enable verbose output",
+    version: "Version heading to use for the generated changelog entry"
+  };
+  buddy.command("changelog", descriptions.changelog).option("-q, --quiet", descriptions.quiet, { default: !1 }).option("-d, --dry-run", descriptions.dryRun, { default: !1 }).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--from <revision>", descriptions.from).option("--to <revision>", descriptions.to).option("--version <version>", descriptions.version).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy changelog` ...", options);
+    const perf = await intro("buddy changelog"), result = await runAction(Action.Changelog, options);
+    if (result.isErr) {
+      await outro("While running the changelog command, there was an issue", { ...options, startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Generated CHANGELOG.md", {
+      ...options,
+      startTime: perf,
+      useSeconds: !0,
+      type: "success"
+    });
+  });
+  onUnknownSubcommand(buddy, "changelog");
+}

package/dist/commands/clean.d.ts

@@ -0,0 +1,2 @@
+import type { CLI } from '@stacksjs/types';
+export declare function clean(buddy: CLI): void;

package/dist/commands/clean.js

@@ -0,0 +1,37 @@
+import process from "node:process";
+import { runAction } from "@stacksjs/actions";
+import { intro, log, onUnknownSubcommand, outro } from "@stacksjs/cli";
+import { Action } from "@stacksjs/enums";
+import { ExitCode } from "@stacksjs/types";
+export function clean(buddy) {
+  const descriptions = {
+    clean: "Removes all node_modules & lock files",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("clean", descriptions.clean).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy clean` ...", options);
+    if (!buddy.isForce && !buddy.isNoInteraction) {
+      const { confirm } = await import("@stacksjs/cli");
+      if (!await confirm({
+        message: "This will remove all node_modules and lock files. Continue?",
+        initial: !1
+      })) {
+        log.info("Clean cancelled");
+        process.exit(ExitCode.Success);
+      }
+    }
+    const perf = await intro("buddy clean"), result = await runAction(Action.Clean, options);
+    if (result.isErr) {
+      await outro("While running the clean command, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Cleaned up", {
+      startTime: perf,
+      useSeconds: !0,
+      message: "Cleaned up"
+    });
+    process.exit(ExitCode.Success);
+  });
+  onUnknownSubcommand(buddy, "clean");
+}

package/dist/commands/cloud.d.ts

@@ -0,0 +1,2 @@
+import type { CLI } from '@stacksjs/types';
+export declare function cloud(buddy: CLI): void;