@stacksjs/buddy 0.70.88 → 0.70.90

package/dist/commands/types.js

@@ -0,0 +1,18 @@
+import process from "node:process";
+import { generateTypes } from "@stacksjs/actions";
+import { log } from "@stacksjs/logging";
+import { onUnknownSubcommand } from "@stacksjs/cli";
+export function types(buddy) {
+  const descriptions = {
+    generate: "Generate the types of & for your library/libraries",
+    fix: "wip",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("types:generate", descriptions.generate).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy types:generate` ...", options);
+    await generateTypes(options);
+  });
+  buddy.command("types:fix", descriptions.fix).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async () => {});
+  onUnknownSubcommand(buddy, "types");
+}

package/dist/commands/upgrade.d.ts

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

package/dist/commands/upgrade.js

@@ -0,0 +1,98 @@
+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 upgrade(buddy) {
+  const descriptions = {
+    upgrade: "Upgrade the Stacks framework to the latest version",
+    version: "Install a specific version (e.g., 0.70.23)",
+    canary: "Upgrade to the latest canary (bleeding-edge `main`) build",
+    stable: "Switch to the latest vetted stable release",
+    dryRun: "Preview the upgrade (which dependencies would change) without writing or installing",
+    force: "Force re-download, bypassing cache and version checks",
+    from: "Sync from a local stacks checkout (e.g. ~/Code/stacks). Skips GitHub.",
+    noPostinstall: "Skip post-sync hooks (auto-imports, bun install, migrate)",
+    verbose: "Enable verbose output",
+    dependencies: "Upgrade your dependencies (pantry.yaml & package.json)",
+    bun: "Upgrade Bun to the latest version",
+    shell: "Upgrade the shell integration (currently only supports Oh My Zsh)",
+    binary: "Upgrade the `stacks` binary to the latest version",
+    project: "Target a specific project",
+    all: "Upgrade framework, dependencies, Bun, and binary"
+  };
+  buddy.command("upgrade", descriptions.upgrade).option("-v, --version <version>", descriptions.version).option("--canary", descriptions.canary, { default: !1 }).option("--stable", descriptions.stable, { default: !1 }).option("--dry-run", descriptions.dryRun, { default: !1 }).option("-f, --force", descriptions.force, { default: !1 }).option("--from <path>", descriptions.from).option("--no-postinstall", descriptions.noPostinstall).option("--verbose", descriptions.verbose, { default: !1 }).alias("update").example("buddy upgrade").example("buddy update").example("buddy upgrade --from ~/Code/stacks").example("buddy upgrade --version 0.70.23").example("buddy upgrade --dry-run").example("buddy upgrade --canary").example("buddy upgrade --stable").example("buddy upgrade --force").action(async (options) => {
+    log.debug("Running `buddy upgrade` ...", options);
+    const opts = { ...options };
+    if (opts.postinstall === !1) {
+      delete opts.postinstall;
+      opts.noPostinstall = !0;
+    }
+    const perf = await intro("buddy upgrade"), result = await runAction(Action.UpgradeFramework, opts);
+    if (result.isErr) {
+      await outro("While running buddy upgrade, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Upgrade complete.", { startTime: perf, useSeconds: !0 });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("upgrade:all", descriptions.all).option("--canary", descriptions.canary, { default: !1 }).option("-f, --force", descriptions.force, { default: !1 }).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).example("buddy upgrade:all").action(async (options) => {
+    log.debug("Running `buddy upgrade:all` ...", options);
+    const perf = await intro("buddy upgrade:all");
+    options.all = !0;
+    const result = await runAction(Action.Upgrade, options);
+    if (result.isErr) {
+      await outro("While running buddy upgrade:all, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("All upgrades complete.", { startTime: perf, useSeconds: !0 });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("upgrade:dependencies", descriptions.dependencies).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).alias("upgrade:deps").example("buddy upgrade:dependencies").action(async (options) => {
+    log.debug("Running `buddy upgrade:dependencies` ...", options);
+    const perf = await intro("buddy upgrade:dependencies");
+    options.dependencies = !0;
+    const result = await runAction(Action.Upgrade, options);
+    if (result.isErr) {
+      await outro("While running buddy upgrade:dependencies, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Dependencies upgraded.", { startTime: perf, useSeconds: !0 });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("upgrade:bun", descriptions.bun).option("--verbose", descriptions.verbose, { default: !1 }).example("buddy upgrade:bun").action(async (options) => {
+    log.debug("Running `buddy upgrade:bun` ...", options);
+    const perf = await intro("buddy upgrade:bun"), result = await runAction(Action.UpgradeBun, options);
+    if (result.isErr) {
+      await outro("While running buddy upgrade:bun, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Bun upgraded.", { startTime: perf, useSeconds: !0 });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("upgrade:shell", descriptions.shell).option("--verbose", descriptions.verbose, { default: !1 }).example("buddy upgrade:shell").action(async (options) => {
+    log.debug("Running `buddy upgrade:shell` ...", options);
+    const perf = await intro("buddy upgrade:shell"), result = await runAction(Action.UpgradeShell, options);
+    if (result.isErr) {
+      await outro("While running buddy upgrade:shell, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Shell integration upgraded.", { startTime: perf, useSeconds: !0 });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("upgrade:binary", descriptions.binary).option("--verbose", descriptions.verbose, { default: !1 }).example("buddy upgrade:binary").action(async (options) => {
+    if (process.getuid && process.getuid() !== 0) {
+      log.warn("To upgrade the binary, you need to run this command with sudo, or as root.");
+      process.exit(ExitCode.FatalError);
+    }
+    log.debug("Running `buddy upgrade:binary` ...", options);
+    const perf = await intro("buddy upgrade:binary"), result = await runAction(Action.UpgradeBinary, options);
+    if (result.isErr) {
+      await outro("While running buddy upgrade:binary, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Binary upgraded.", { startTime: perf, useSeconds: !0 });
+    process.exit(ExitCode.Success);
+  });
+  onUnknownSubcommand(buddy, "upgrade");
+}

package/dist/commands/version.d.ts

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

package/dist/commands/version.js

@@ -0,0 +1,16 @@
+import process from "node:process";
+import { bold, dim, green, intro, log, onUnknownSubcommand } from "@stacksjs/cli";
+import { storage } from "@stacksjs/storage";
+export function version(buddy) {
+  const descriptions = {
+    version: "Retrieving Stacks build version"
+  };
+  buddy.command("version", descriptions.version).action(async () => {
+    log.debug("Running `buddy version` ...");
+    await intro("buddy version");
+    const pkg = await storage.readPackageJson("./package.json"), bunVersion = "wip", stacksVersion = pkg.version;
+    log.info(green(bold("@stacksjs/ ")) + dim(` ${stacksVersion}`));
+    log.info(green(bold("Bun: ")) + dim(`   ${bunVersion}`));
+  });
+  onUnknownSubcommand(buddy, "version");
+}

package/dist/config.d.ts

@@ -0,0 +1,43 @@
+import type { CLI } from '@stacksjs/cli';
+/**
+ * Validate the buddy config structure
+ */
+export declare function validateConfig(config: any): ValidationError[];
+/**
+ * Load buddy.config.ts from the project root
+ */
+export declare function loadBuddyConfig(): Promise<BuddyConfig>;
+/**
+ * Load and initialize plugins
+ */
+export declare function loadPlugins(cli: CLI, config: BuddyConfig): Promise<void>;
+/**
+ * Apply buddy config to CLI instance
+ */
+export declare function applyBuddyConfig(buddy: CLI): Promise<void>;
+export declare interface BuddyPlugin {
+  name: string
+  version?: string
+  setup: (cli: CLI) => void | Promise<void>
+  hooks?: {
+    beforeCommand?: (context: any) => void | Promise<void>
+    afterCommand?: (context: any) => void | Promise<void>
+  }
+}
+export declare interface BuddyConfig {
+  theme?: string
+  emoji?: boolean
+  commands?: Array<(cli: CLI) => void>
+  defaultFlags?: {
+    verbose?: boolean
+    quiet?: boolean
+    debug?: boolean
+  }
+  aliases?: Record<string, string>
+  plugins?: Array<BuddyPlugin | string>
+}
+declare interface ValidationError {
+  path: string
+  message: string
+  value?: any
+}

package/dist/config.js

@@ -0,0 +1,223 @@
+import { existsSync } from "node:fs";
+import { log } from "@stacksjs/cli";
+import { path as p } from "@stacksjs/path";
+export function validateConfig(config) {
+  const errors = [];
+  if (typeof config !== "object" || config === null) {
+    errors.push({
+      path: "config",
+      message: "Config must be an object",
+      value: config
+    });
+    return errors;
+  }
+  if (config.theme !== void 0) {
+    const validThemes = ["default", "dracula", "nord", "solarized", "monokai"];
+    if (typeof config.theme !== "string" || !validThemes.includes(config.theme))
+      errors.push({
+        path: "theme",
+        message: `Theme must be one of: ${validThemes.join(", ")}`,
+        value: config.theme
+      });
+  }
+  if (config.emoji !== void 0 && typeof config.emoji !== "boolean")
+    errors.push({
+      path: "emoji",
+      message: "Emoji must be a boolean",
+      value: config.emoji
+    });
+  if (config.commands !== void 0)
+    if (!Array.isArray(config.commands))
+      errors.push({
+        path: "commands",
+        message: "Commands must be an array",
+        value: config.commands
+      });
+    else
+      config.commands.forEach((cmd, index) => {
+        if (typeof cmd !== "function")
+          errors.push({
+            path: `commands[${index}]`,
+            message: "Each command must be a function",
+            value: cmd
+          });
+      });
+  if (config.defaultFlags !== void 0)
+    if (typeof config.defaultFlags !== "object" || config.defaultFlags === null)
+      errors.push({
+        path: "defaultFlags",
+        message: "Default flags must be an object",
+        value: config.defaultFlags
+      });
+    else {
+      const flagKeys = ["verbose", "quiet", "debug"];
+      for (const key of Object.keys(config.defaultFlags))
+        if (!flagKeys.includes(key))
+          errors.push({
+            path: `defaultFlags.${key}`,
+            message: `Unknown flag. Valid flags are: ${flagKeys.join(", ")}`,
+            value: config.defaultFlags[key]
+          });
+        else if (typeof config.defaultFlags[key] !== "boolean")
+          errors.push({
+            path: `defaultFlags.${key}`,
+            message: "Flag value must be a boolean",
+            value: config.defaultFlags[key]
+          });
+    }
+  if (config.aliases !== void 0) {
+    if (typeof config.aliases !== "object" || config.aliases === null || Array.isArray(config.aliases))
+      errors.push({
+        path: "aliases",
+        message: "Aliases must be an object mapping alias names to command names",
+        value: config.aliases
+      });
+    else
+      for (const [alias, command] of Object.entries(config.aliases))
+        if (typeof command !== "string")
+          errors.push({
+            path: `aliases.${alias}`,
+            message: "Alias target must be a string",
+            value: command
+          });
+  }
+  if (config.plugins !== void 0)
+    if (!Array.isArray(config.plugins))
+      errors.push({
+        path: "plugins",
+        message: "Plugins must be an array",
+        value: config.plugins
+      });
+    else
+      config.plugins.forEach((plugin, index) => {
+        if (typeof plugin === "string")
+          return;
+        if (typeof plugin !== "object" || plugin === null) {
+          errors.push({
+            path: `plugins[${index}]`,
+            message: "Each plugin must be an object or a string (module path)",
+            value: plugin
+          });
+          return;
+        }
+        if (!plugin.name || typeof plugin.name !== "string")
+          errors.push({
+            path: `plugins[${index}].name`,
+            message: "Plugin must have a name property of type string",
+            value: plugin.name
+          });
+        if (!plugin.setup || typeof plugin.setup !== "function")
+          errors.push({
+            path: `plugins[${index}].setup`,
+            message: "Plugin must have a setup function",
+            value: plugin.setup
+          });
+        if (plugin.hooks !== void 0) {
+          if (typeof plugin.hooks !== "object" || plugin.hooks === null)
+            errors.push({
+              path: `plugins[${index}].hooks`,
+              message: "Plugin hooks must be an object",
+              value: plugin.hooks
+            });
+        }
+      });
+  const validKeys = ["theme", "emoji", "commands", "defaultFlags", "aliases", "plugins"];
+  for (const key of Object.keys(config))
+    if (!validKeys.includes(key))
+      errors.push({
+        path: key,
+        message: `Unknown configuration key. Valid keys are: ${validKeys.join(", ")}`,
+        value: config[key]
+      });
+  return errors;
+}
+let cachedConfig = null;
+export async function loadBuddyConfig() {
+  if (cachedConfig)
+    return cachedConfig;
+  const configPaths = [
+    p.projectPath("buddy.config.ts"),
+    p.projectPath("buddy.config.js"),
+    p.projectPath(".buddy.config.ts"),
+    p.projectPath(".buddy.config.js")
+  ];
+  for (const configPath of configPaths)
+    if (existsSync(configPath))
+      try {
+        log.debug(`Loading buddy config from ${configPath}`);
+        const configModule = await import(configPath), config = configModule.default || configModule, validationErrors = validateConfig(config);
+        if (validationErrors.length > 0) {
+          log.error("Invalid buddy.config.ts:");
+          for (const error of validationErrors)
+            log.error(`  - ${error.path}: ${error.message}`);
+          throw Error("Configuration validation failed");
+        }
+        cachedConfig = config;
+        return config;
+      } catch (error) {
+        log.warn(`Failed to load buddy config from ${configPath}:`, error);
+      }
+  cachedConfig = {};
+  return cachedConfig;
+}
+export async function loadPlugins(cli, config) {
+  if (!config.plugins || config.plugins.length === 0)
+    return;
+  log.debug(`Loading ${config.plugins.length} plugin(s)`);
+  for (const pluginConfig of config.plugins) {
+    let plugin;
+    if (typeof pluginConfig === "string")
+      try {
+        const pluginModule = await import(pluginConfig);
+        plugin = pluginModule.default || pluginModule;
+      } catch (error) {
+        log.error(`Failed to load plugin from ${pluginConfig}:`, error);
+        continue;
+      }
+    else
+      plugin = pluginConfig;
+    try {
+      log.debug(`Initializing plugin: ${plugin.name}${plugin.version ? ` v${plugin.version}` : ""}`);
+      await plugin.setup(cli);
+      if (plugin.hooks) {
+        if (plugin.hooks.beforeCommand)
+          cli.on("command:*", async (command) => {
+            if (plugin.hooks?.beforeCommand)
+              await plugin.hooks.beforeCommand({ command });
+          });
+        if (plugin.hooks.afterCommand)
+          cli.on("command:*", async (command) => {
+            if (plugin.hooks?.afterCommand)
+              await plugin.hooks.afterCommand({ command });
+          });
+      }
+      log.debug(`Plugin ${plugin.name} initialized successfully`);
+    } catch (error) {
+      log.error(`Failed to initialize plugin ${plugin.name}:`, error);
+    }
+  }
+}
+export async function applyBuddyConfig(buddy) {
+  const config = await loadBuddyConfig();
+  if (config.emoji !== void 0 && buddy.options.noEmoji === void 0)
+    buddy.useEmoji = config.emoji;
+  if (config.defaultFlags) {
+    if (config.defaultFlags.verbose && !buddy.isVerbose)
+      buddy.isVerbose = !0;
+    if (config.defaultFlags.quiet && !buddy.isQuiet)
+      buddy.isQuiet = !0;
+    if (config.defaultFlags.debug && !buddy.isDebug)
+      buddy.isDebug = !0;
+  }
+  if (config.commands && Array.isArray(config.commands)) {
+    for (const registerCommand of config.commands)
+      if (typeof registerCommand === "function")
+        registerCommand(buddy);
+  }
+  if (config.aliases)
+    for (const [alias, command] of Object.entries(config.aliases)) {
+      const targetCommand = buddy.commands.find((cmd) => cmd.name === command);
+      if (targetCommand && !targetCommand.aliasNames.includes(alias))
+        targetCommand.aliasNames.push(alias);
+    }
+}

package/dist/custom-cli.d.ts

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

package/dist/custom-cli.js

@@ -0,0 +1,23 @@
+import process from "node:process";
+import { cli } from "@stacksjs/cli";
+import { config } from "@stacksjs/config";
+import { handleError } from "@stacksjs/error-handling";
+import { path as p } from "@stacksjs/path";
+import { fs } from "@stacksjs/storage";
+process.on("uncaughtException", handleError);
+process.on("unhandledRejection", handleError);
+async function main() {
+  const buddy = cli(config.cli.name);
+  if (!fs.existsSync(p.projectPath(config.cli.command)))
+    fs.writeFileSync(p.projectPath(config.cli.command), "import('./storage/framework/core/buddy/src/custom-cli')");
+  const commandsDir = p.appPath("Commands"), commandFiles = fs.readdirSync(commandsDir).filter((file) => file.endsWith(".ts"));
+  for (const file of commandFiles) {
+    const dynamicImport = await import(`${commandsDir}/${file}`);
+    if (typeof dynamicImport.default === "function")
+      dynamicImport.default(buddy);
+    else
+      console.error(`Expected a default export function in ${file}, but got:`, dynamicImport.default);
+  }
+  buddy.parse();
+}
+await main();

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './commands/index';

package/dist/index.js

@@ -0,0 +1 @@
+export * from "./commands";

package/dist/lazy-commands.d.ts

@@ -0,0 +1,61 @@
+import type { CLI } from '@stacksjs/types';
+/** Mark a registrar as already invoked for this CLI so loadCommand skips it. */
+export declare function markLoaded(buddy: CLI, commandName: string): void;
+/**
+ * Load a specific command lazily
+ */
+export declare function loadCommand(commandName: string, buddy: CLI): Promise<boolean>;
+/**
+ * Load multiple commands with timeout.
+ *
+ * Many registry entries point at the same module (e.g. `down`, `up`, `status`,
+ * `maintenance` all share `./commands/maintenance.ts`, and `cloud:*` aliases
+ * share `./commands/cloud.ts`). Calling each registrar more than once would
+ * register the same sub-commands multiple times, which is what produces
+ * duplicate rows in `buddy list`. Dedupe by loader identity so each module's
+ * registrar runs at most once per CLI instance.
+ */
+export declare function loadCommands(commandNames: string[], buddy: CLI): Promise<void>;
+/**
+ * Load a group of related commands
+ */
+export declare function loadCommandGroup(groupName: keyof typeof commandGroups, buddy: CLI): Promise<void>;
+/**
+ * Load all commands (for interactive mode or list command)
+ */
+export declare function loadAllCommands(buddy: CLI): Promise<void>;
+/**
+ * Get command names for autocomplete/suggestions
+ * (without actually loading the commands)
+ */
+export declare function getCommandNames(): string[];
+/**
+ * Determine which commands to load based on CLI arguments.
+ *
+ * Help / no-command paths must load the full registry so the rendered help
+ * lists every command. Pure version flags only need `version`. A specific
+ * command (with or without `--help`) only needs that command's loader.
+ */
+export declare function getCommandsToLoad(args: string[]): string[];
+/**
+ * Commands that are commonly used together (for batch loading optimization)
+ * @defaultValue
+ * ```ts
+ * {
+ *   'minimal': ['version', 'help'],
+ *   'development': ['dev', 'build', 'test', 'lint'],
+ *   'database': ['migrate', 'seed', 'fresh'],
+ *   'scaffolding': ['make', 'generate'],
+ *   'deployment': ['deploy', 'release', 'cloud'],
+ *   'info': ['about', 'doctor', 'list']
+ * }
+ * ```
+ */
+declare const commandGroups: {
+  'minimal': string[];
+  'development': string[];
+  'database': string[];
+  'scaffolding': string[];
+  'deployment': string[];
+  'info': string[]
+};