@stacksjs/buddy 0.70.88 → 0.70.91

package/dist/commands/index.js

@@ -0,0 +1,53 @@
+export * from "./about";
+export * from "./auth";
+export * from "./build";
+export * from "./cd";
+export * from "./changelog";
+export * from "./clean";
+export * from "./cloud";
+export * from "./commit";
+export * from "./completion";
+export * from "./config-migrate";
+export * from "./configure";
+export * from "./create";
+export * from "./deploy";
+export * from "./dev";
+export * from "./dns";
+export * from "./doctor";
+export * from "./domains";
+export * from "./email";
+export * from "./env";
+export * from "./features";
+export * from "./fresh";
+export * from "./generate";
+export * from "./http";
+export * from "./install";
+export * from "./key";
+export * from "./lint";
+export * from "./list";
+export * from "./mail";
+export * from "./make";
+export * from "./migrate";
+export * from "./migrate-project";
+export * from "./outdated";
+export * from "./phone";
+export * from "./ports";
+export * from "./prepublish";
+export * from "./projects";
+export * from "./publish";
+export * from "./queue";
+export * from "./release";
+export * from "./route";
+export * from "./saas";
+export * from "./schedule";
+export * from "./search";
+export * from "./seed";
+export * from "./serve";
+export * from "./setup";
+export * from "./sms";
+export * from "./telemetry";
+export * from "./test";
+export * from "./tinker";
+export * from "./types";
+export * from "./upgrade";
+export * from "./version";

package/dist/commands/install.d.ts

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

package/dist/commands/install.js

@@ -0,0 +1,22 @@
+import process from "node:process";
+import { log, onUnknownSubcommand, runCommand } from "@stacksjs/cli";
+import { path as p } from "@stacksjs/path";
+import { ExitCode } from "@stacksjs/types";
+export function install(buddy) {
+  const descriptions = {
+    install: "Install your dependencies",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("install", descriptions.install).option("-p, --project [project]", descriptions.project, { default: !1 }).option("-v, --verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy install` ...", options);
+    if ((await runCommand("bun install", {
+      ...options,
+      cwd: p.projectPath()
+    })).isErr) {
+      log.error("bun install failed");
+      process.exit(ExitCode.FatalError);
+    }
+  });
+  onUnknownSubcommand(buddy, "install");
+}

package/dist/commands/key.d.ts

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

package/dist/commands/key.js

@@ -0,0 +1,23 @@
+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 key(buddy) {
+  const descriptions = {
+    command: "Generate & set the application key.",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("key:generate", descriptions.command).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy key:generate` ...", options);
+    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(ExitCode.FatalError);
+    }
+    await outro("Random application key set.");
+  });
+  onUnknownSubcommand(buddy, "key");
+}

package/dist/commands/lint.d.ts

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

package/dist/commands/lint.js

@@ -0,0 +1,46 @@
+import process from "node:process";
+import { intro, log, onUnknownSubcommand, outro } from "@stacksjs/cli";
+import { ExitCode } from "@stacksjs/types";
+async function runStyleAction(entry, label, options) {
+  const actions = await import("@stacksjs/actions"), { ok } = await actions[entry](options);
+  if (!ok) {
+    log.error(`${label} reported failure`);
+    process.exit(ExitCode.FatalError);
+  }
+}
+export function lint(buddy) {
+  const descriptions = {
+    lint: "Automagically lints your project codebase",
+    lintFix: "Automagically fixes all lint errors",
+    format: "Format your project codebase",
+    formatCheck: "Check formatting without making changes",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("lint", descriptions.lint).option("-f, --fix", descriptions.lintFix, { default: !1 }).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy lint` ...", options);
+    const startTime = await intro("buddy lint");
+    await runStyleAction(options.fix ? "lintFix" : "lintProject", "lint");
+    await outro("Linted your project", { startTime, useSeconds: !0 });
+  });
+  buddy.command("lint:fix", descriptions.lintFix).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy lint:fix` ...", options);
+    const startTime = await intro("buddy lint:fix");
+    log.info("Fixing lint errors...");
+    await runStyleAction("lintFix", "lint:fix");
+    await outro("Fixed lint errors", { startTime, useSeconds: !0 });
+  });
+  buddy.command("format", descriptions.format).option("-w, --write", "Write changes to files", { default: !1 }).option("-c, --check", descriptions.formatCheck, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy format` ...", options);
+    const startTime = await intro("buddy format");
+    await runStyleAction("formatProject", "format", options.check ? { check: !0 } : { write: !0 });
+    await outro("Formatted your project", { startTime, useSeconds: !0 });
+  });
+  buddy.command("format:check", descriptions.formatCheck).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy format:check` ...", options);
+    const startTime = await intro("buddy format:check");
+    await runStyleAction("formatProject", "format:check", { check: !0 });
+    await outro("Format check complete", { startTime, useSeconds: !0 });
+  });
+  onUnknownSubcommand(buddy, "lint");
+}

package/dist/commands/list.d.ts

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

package/dist/commands/list.js

@@ -0,0 +1,108 @@
+import process from "node:process";
+import { log } from "@stacksjs/logging";
+import { onUnknownSubcommand } from "@stacksjs/cli";
+export function list(buddy) {
+  const descriptions = {
+    list: "List all available Buddy commands",
+    project: "Target a specific project",
+    verbose: "Enable verbose output",
+    filter: "Filter commands by name or group",
+    namespace: "Filter commands by namespace (e.g., make, env, db)",
+    grouped: "Group commands by category",
+    format: "Output format (text, json)"
+  };
+  buddy.command("list", descriptions.list).option("-p, --project [project]", descriptions.project, { default: !1 }).option("-f, --filter [filter]", descriptions.filter).option("-n, --namespace [namespace]", descriptions.namespace).option("-g, --grouped", descriptions.grouped, { default: !0 }).option("--format [format]", descriptions.format, { default: "text" }).option("--verbose", descriptions.verbose, { default: !1 }).example("buddy list").example("buddy list --filter=make").example("buddy list --namespace=make").example("buddy list --namespace=env").example("buddy list --no-grouped").example("buddy list --format=json").action(async (options) => {
+    log.debug("Running `buddy list` ...", options);
+    const { bold, dim, green } = await import("@stacksjs/cli"), commands = buddy.commands || [];
+    let filteredCommands = commands;
+    if (options.filter) {
+      const filterStr = String(options.filter).toLowerCase();
+      filteredCommands = commands.filter((cmd) => {
+        const name = cmd.name || "", desc = cmd.description || "";
+        return name.toLowerCase().includes(filterStr) || desc.toLowerCase().includes(filterStr);
+      });
+    }
+    if (options.namespace) {
+      const namespaceStr = String(options.namespace).toLowerCase();
+      filteredCommands = filteredCommands.filter((cmd) => {
+        return (cmd.namespace || "").toLowerCase() === namespaceStr;
+      });
+    }
+    if (filteredCommands.length === 0) {
+      if (options.format === "json")
+        console.log(JSON.stringify({ commands: [], total: 0 }, null, 2));
+      else {
+        console.log(dim("No commands found"));
+        if (options.filter)
+          console.log(dim(`Try removing the filter: ${options.filter}`));
+      }
+      return;
+    }
+    if (options.format === "json") {
+      const jsonOutput = filteredCommands.map((cmd) => ({
+        name: cmd.name || "",
+        description: cmd.description || "",
+        aliases: cmd.aliasNames || []
+      }));
+      console.log(JSON.stringify({ commands: jsonOutput, total: jsonOutput.length }, null, 2));
+      return;
+    }
+    if (options.grouped) {
+      const groups = new Map;
+      for (const cmd of filteredCommands) {
+        const name = cmd.name || "";
+        if (!name)
+          continue;
+        let group = "General";
+        if (name.includes(":"))
+          group = name.split(":")[0] ?? "General";
+        else if (["dev", "build", "test", "lint"].includes(name))
+          group = "Development";
+        else if (["deploy", "release", "publish"].includes(name))
+          group = "Deployment";
+        else if (["migrate", "seed", "fresh"].includes(name))
+          group = "Database";
+        else if (["doctor", "about", "version"].includes(name))
+          group = "Info";
+        if (!groups.has(group))
+          groups.set(group, []);
+        groups.get(group).push(cmd);
+      }
+      console.log("");
+      console.log(bold(green("Available Commands:")));
+      console.log("");
+      const sortedGroups = Array.from(groups.entries()).sort((a, b) => {
+        const order = ["Development", "General", "Info"], aIndex = order.indexOf(a[0]), bIndex = order.indexOf(b[0]);
+        if (aIndex >= 0 && bIndex >= 0)
+          return aIndex - bIndex;
+        if (aIndex >= 0)
+          return -1;
+        if (bIndex >= 0)
+          return 1;
+        return a[0].localeCompare(b[0]);
+      });
+      for (const [group, cmds] of sortedGroups) {
+        console.log(bold(`${group}:`));
+        cmds.sort((a, b) => (a.name || "").localeCompare(b.name || ""));
+        for (const cmd of cmds) {
+          const name = (cmd.name || "").padEnd(20), desc = cmd.description || "";
+          console.log(`  ${green(name)} ${dim(desc)}`);
+        }
+        console.log("");
+      }
+    } else {
+      console.log("");
+      console.log(bold(green("Available Commands:")));
+      console.log("");
+      filteredCommands.sort((a, b) => (a.name || "").localeCompare(b.name || ""));
+      for (const cmd of filteredCommands) {
+        const name = (cmd.name || "").padEnd(20), desc = cmd.description || "";
+        console.log(`  ${green(name)} ${dim(desc)}`);
+      }
+      console.log("");
+    }
+    console.log(dim(`Total: ${filteredCommands.length} commands`));
+    console.log("");
+  });
+  onUnknownSubcommand(buddy, "list");
+}

package/dist/commands/mail.d.ts

@@ -0,0 +1,4 @@
+import { CLI } from '@stacksjs/clapp';
+export declare function resolveDirectMailHost(env?: NodeJS.ProcessEnv): string | undefined;
+export declare function sanitizeLineCount(value?: string): string;
+export declare function mailCommands(buddy: CLI): void;