@stacksjs/buddy 0.70.59 → 0.70.61

package/dist/commands/fresh.js

@@ -0,0 +1,39 @@
+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 fresh(buddy) {
+  const descriptions = {
+    fresh: "Re-installs your npm dependencies",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("fresh", descriptions.fresh).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy fresh` ...", options);
+    if (!buddy.isForce && !buddy.isNoInteraction) {
+      const { confirm } = await import("@stacksjs/cli");
+      if (!await confirm({
+        message: "This will remove and reinstall all dependencies. Continue?",
+        initial: !1
+      })) {
+        log.info("Fresh install cancelled");
+        process.exit(ExitCode.Success);
+      }
+    }
+    const perf = await intro("buddy fresh"), result = await runAction(Action.Fresh, {
+      ...options,
+      stdout: "inherit"
+    });
+    if (result.isErr) {
+      await outro("While running `buddy fresh`, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Freshly reinstalled your dependencies", {
+      startTime: perf,
+      useSeconds: !0
+    });
+    process.exit(ExitCode.Success);
+  });
+  onUnknownSubcommand(buddy, "fresh");
+}

package/dist/commands/generate.js

@@ -0,0 +1,104 @@
+import process from "node:process";
+import {
+  generateComponentMeta,
+  generateCoreSymlink,
+  generateIdeHelpers,
+  generateLibEntries,
+  generateOpenApiSpec,
+  generatePantryConfig,
+  generateTypes,
+  generateVsCodeCustomData,
+  generateWebTypes,
+  invoke as startGenerationProcess,
+  watchTypes
+} from "@stacksjs/actions";
+import { intro, log, onUnknownSubcommand, outro } from "@stacksjs/cli";
+import { ExitCode } from "@stacksjs/types";
+export 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",
+    componentMeta: "Generate component meta information",
+    coreSymlink: "Generate symlink of the core framework to the project root",
+    pantry: "Generate the pantry configuration file",
+    openApi: "Generate the OpenAPI specification",
+    select: "What are you trying to generate?",
+    project: "Target a specific project",
+    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("-c, --component-meta", descriptions.componentMeta).option("-p, --pantry", descriptions.pantry).option("-o, --openapi", descriptions.openApi).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--core-symlink", descriptions.coreSymlink).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy generate` ...", options);
+    await startGenerationProcess(options);
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("generate:types", descriptions.types).option("-p, --project [project]", descriptions.project, { default: !1 }).option("-w, --watch", "Re-run on changes to models/ and config/", { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).alias("types:generate").action(async (options) => {
+    log.debug("Running `buddy generate:types` ...", options);
+    await generateTypes(options);
+    try {
+      const { buildDatabaseSchema } = await import("@stacksjs/orm");
+      await buildDatabaseSchema();
+    } catch (err) {
+      log.warn(`[generate:db-types] skipped: ${err.message}`);
+    }
+    if (options.watch)
+      await watchTypes(options);
+  });
+  buddy.command("generate:db-types", "Refresh database/types.d.ts for db.selectFrom autocomplete (stacksjs/stacks#1923)").option("--dry-run", "Print the would-be file content without writing", { default: !1 }).action(async (options) => {
+    const { buildDatabaseSchema } = await import("@stacksjs/orm"), result = await buildDatabaseSchema({ dryRun: options.dryRun });
+    if (options.dryRun)
+      console.log(result.content);
+    for (const e of result.errors)
+      log.warn(`[generate:db-types] ${e.file}: ${e.error}`);
+    log.info(`[generate:db-types] resolved ${result.tables.length} table(s)`);
+  });
+  buddy.command("generate:entries", descriptions.entries).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy generate:entries` ...", options);
+    await generateLibEntries(options);
+  });
+  buddy.command("generate:web-types", descriptions.webTypes).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy generate:web-types` ...", options);
+    await generateWebTypes(options);
+  });
+  buddy.command("generate:vscode-custom-data", descriptions.customData).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy generate:vscode-custom-data` ...", options);
+    await generateVsCodeCustomData(options);
+  });
+  buddy.command("generate:ide-helpers", descriptions.ideHelpers).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy generate:ide-helpers` ...", options);
+    await generateIdeHelpers(options);
+  });
+  buddy.command("generate:component-meta", descriptions.componentMeta).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy generate:component-meta` ...", options);
+    await generateComponentMeta();
+  });
+  buddy.command("generate:pantry-config", descriptions.pantry).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy generate:pantry-config` ...", options);
+    await generatePantryConfig();
+  });
+  buddy.command("generate:openapi-spec", descriptions.openApi).alias("generate:openapi").option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy generate:openapi-spec` ...", options);
+    const perf = await intro("buddy generate:openapi-spec");
+    await generateOpenApiSpec();
+    await outro("Generated OpenAPI specification", {
+      startTime: perf,
+      useSeconds: !0
+    });
+  });
+  buddy.command("generate:migrations", "Generate Migrations").action(async (options) => {
+    log.debug("Running `buddy generate:migrations` ...", options);
+    const { generateMigrations } = await import("@stacksjs/database"), result = await generateMigrations();
+    if (result?.isErr) {
+      log.error("generateMigrations failed", result.error);
+      process.exit(ExitCode.FatalError);
+    }
+  });
+  buddy.command("generate:core-symlink", "Generate core symlink. A shortcut for core developers.").action(async (options) => {
+    log.debug("Running `buddy core-symlink` ...", options);
+    await generateCoreSymlink();
+  });
+  onUnknownSubcommand(buddy, "generate");
+}

package/dist/commands/http.js

@@ -0,0 +1,30 @@
+import process from "node:process";
+import { log } from "@stacksjs/cli";
+import { config } from "@stacksjs/config";
+import { HttxClient } from "@stacksjs/httx";
+import { ExitCode } from "@stacksjs/types";
+export function http(buddy) {
+  const descriptions = {
+    http: "Send an HTTP request to a domain",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("http [domain]", descriptions.http).option("-p, --project [project]", descriptions.project, { default: !1 }).option("-v, --verbose", descriptions.verbose, { default: !1 }).action(async (domain, options) => {
+    log.debug("Running `buddy http [domain]` ...", options);
+    const url = domain || config.app.url, client = new HttxClient({ verbose: options.verbose });
+    log.info(`GET ${url}`);
+    (await client.request(url.startsWith("http") ? url : `https://${url}`, {
+      method: "GET"
+    })).match({
+      ok: (response) => {
+        log.info(`${response.status} ${response.statusText} (${response.timings.duration.toFixed(0)}ms)`);
+        console.log(typeof response.data === "string" ? response.data : JSON.stringify(response.data, null, 2));
+        process.exit(ExitCode.Success);
+      },
+      err: (error) => {
+        log.error(`Request failed: ${error.message}`);
+        process.exit(ExitCode.FatalError);
+      }
+    });
+  });
+}

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.js

@@ -0,0 +1,23 @@
+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);
+    const result = await runCommand("bun install", {
+      ...options,
+      cwd: p.projectPath()
+    });
+    if (result && typeof result === "object" && "isErr" in result && result.isErr?.()) {
+      log.error("bun install failed");
+      process.exit(ExitCode.FatalError);
+    }
+  });
+  onUnknownSubcommand(buddy, "install");
+}

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.js

@@ -0,0 +1,50 @@
+import process from "node:process";
+import { intro, log, onUnknownSubcommand, outro, runCommand } from "@stacksjs/cli";
+import { path } from "@stacksjs/path";
+import { ExitCode } from "@stacksjs/types";
+function exitOnFailure(result, label) {
+  if (!result || typeof result !== "object" || !("isErr" in result))
+    return;
+  const marker = result.isErr;
+  if (typeof marker === "function" ? marker() : marker === !0) {
+    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"), result = options.fix ? await runCommand("bun storage/framework/core/actions/src/lint/fix.ts", { cwd: path.projectPath() }) : await runCommand("bun storage/framework/core/actions/src/lint/index.ts", { cwd: path.projectPath() });
+    exitOnFailure(result, "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...");
+    const result = await runCommand("bun storage/framework/core/actions/src/lint/fix.ts", { cwd: path.projectPath() });
+    exitOnFailure(result, "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"), result = options.check ? await runCommand("bunx --bun pickier run --mode format --config ./pickier.config.ts --check", { cwd: path.projectPath() }) : await runCommand("bunx --bun pickier run --mode format --config ./pickier.config.ts --write", { cwd: path.projectPath() });
+    exitOnFailure(result, "format");
+    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"), result = await runCommand("bunx --bun pickier run --mode format --config ./pickier.config.ts --check", { cwd: path.projectPath() });
+    exitOnFailure(result, "format:check");
+    await outro("Format check complete", { startTime, useSeconds: !0 });
+  });
+  onUnknownSubcommand(buddy, "lint");
+}

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];
+        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");
+}