@stacksjs/buddy 0.70.88 → 0.70.91

package/dist/commands/sms.js

@@ -0,0 +1,328 @@
+import { getErrorMessage } from "@stacksjs/utils";
+import { readFileSync, existsSync } from "node:fs";
+const TIMEOUT_MS = 30000;
+async function withTimeout(promise, ms = TIMEOUT_MS) {
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => reject(Error(`Operation timed out after ${ms}ms`)), ms);
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+function loadAwsCredentials() {
+  const envPath = ".env.production";
+  if (existsSync(envPath)) {
+    const content = readFileSync(envPath, "utf-8");
+    for (const line of content.split(`
+`)) {
+      const eq = line.indexOf("=");
+      if (eq > 0 && !line.startsWith("#"))
+        process.env[line.slice(0, eq).trim()] = line.slice(eq + 1).trim();
+    }
+  }
+}
+const descriptions = {
+  sms: "SMS service management commands",
+  status: "Show SMS service status",
+  send: "Send a test SMS",
+  setup: "Initialize SMS infrastructure",
+  verify: "Verify a sandbox phone number",
+  "add-phone": "Add a phone to sandbox for testing"
+};
+export function sms(buddy) {
+  buddy.command("sms", descriptions.sms).action(async () => {
+    console.log(`
+\uD83D\uDCF1 SMS Service Commands
+`);
+    console.log("  buddy sms:status     - Show SMS service status");
+    console.log("  buddy sms:send       - Send a test SMS");
+    console.log("  buddy sms:setup      - Initialize SMS infrastructure");
+    console.log("  buddy sms:add-phone  - Add a phone to sandbox for testing");
+    console.log("  buddy sms:verify     - Verify a sandbox phone number with OTP");
+    console.log("");
+    process.exit(0);
+  });
+  buddy.command("sms:status", descriptions.status).action(async () => {
+    console.log(`
+\uD83D\uDCF1 SMS Service Status
+`);
+    loadAwsCredentials();
+    try {
+      const { getSmsInfrastructureStatus } = await import("@stacksjs/ts-cloud"), status = await withTimeout(getSmsInfrastructureStatus({
+        region: process.env.AWS_REGION || "us-east-1",
+        accountName: "stacks"
+      }), 30000);
+      console.log("Phone Numbers:");
+      if (status.phoneNumbers.length === 0) {
+        console.log("  No phone numbers provisioned");
+        console.log("  Run `buddy sms:setup` to provision a phone number");
+      } else
+        for (const phone of status.phoneNumbers) {
+          console.log(`  ${phone.phoneNumber}`);
+          console.log(`    Status: ${phone.status}`);
+          console.log(`    Two-Way: ${phone.twoWayEnabled ? "Enabled" : "Disabled"}`);
+          console.log(`    Capabilities: ${phone.capabilities.join(", ") || "N/A"}`);
+        }
+      console.log(`
+Account:`);
+      console.log(`  Sandbox Status: ${status.sandboxStatus === "IN_SANDBOX" ? "\u26A0\uFE0F In Sandbox" : "\u2705 Production"}`);
+      console.log(`  Spending Limit: $${status.spendingLimit}/month`);
+      console.log(`
+SNS Topics:`);
+      if (status.topics.length === 0)
+        console.log("  No SMS topics configured");
+      else
+        for (const topic of status.topics)
+          console.log(`  ${topic.name}`);
+      if (status.sandboxStatus === "IN_SANDBOX") {
+        console.log(`
+\uD83D\uDCA1 To exit sandbox mode:`);
+        console.log("   Run `buddy sms:setup` to file a support request");
+        console.log("   Or visit AWS Console > End User Messaging > SMS > Request production access");
+      }
+      if (status.phoneNumbers.some((p) => p.status === "PENDING"))
+        console.log(`
+\u23F3 Note: Phone number verification can take 24-72 hours for toll-free numbers`);
+    } catch (error) {
+      console.error("Error checking status:", getErrorMessage(error));
+      try {
+        const { PinpointSmsVoiceClient } = await import("@stacksjs/ts-cloud"), smsClient = new PinpointSmsVoiceClient(process.env.AWS_REGION || "us-east-1"), activeNumbers = (await withTimeout(smsClient.describePhoneNumbers({}))).PhoneNumbers?.filter((p) => p.Status === "ACTIVE" || p.Status === "PENDING");
+        if (activeNumbers && activeNumbers.length > 0) {
+          console.log(`
+\u2705 SMS Service Active (End User Messaging)`);
+          for (const phone of activeNumbers)
+            console.log(`  Phone: ${phone.PhoneNumber} (${phone.Status})`);
+        } else {
+          console.log(`
+\u274C SMS service not deployed.`);
+          console.log("   Run `buddy sms:setup` to initialize");
+        }
+      } catch {
+        console.log(`
+\u274C Could not connect to AWS. Check credentials.`);
+      }
+    }
+    process.exit(0);
+  });
+  buddy.command("sms:send <phone> [message]", descriptions.send).option("--template <name>", "Use a message template").action(async (phone, message, options) => {
+    const msg = message || "Test message from Stacks";
+    console.log(`
+\uD83D\uDCF1 Sending SMS to ${phone}...
+`);
+    loadAwsCredentials();
+    try {
+      const { SMSClient } = await import("@stacksjs/ts-cloud"), smsClient = new SMSClient({
+        region: process.env.AWS_REGION || "us-east-1"
+      }), smsConfig = await import("@stacksjs/config").then((m) => m.config?.sms);
+      let originationNumber = smsConfig?.originationNumber;
+      if (!originationNumber) {
+        const { PinpointSmsVoiceClient } = await import("@stacksjs/ts-cloud"), pinpointV2 = new PinpointSmsVoiceClient(process.env.AWS_REGION || "us-east-1");
+        originationNumber = (await withTimeout(pinpointV2.describePhoneNumbers({}))).PhoneNumbers?.find((p) => p.Status === "ACTIVE")?.PhoneNumber;
+      }
+      let finalMessage = msg;
+      if (options?.template && smsConfig?.templates) {
+        const template = smsConfig.templates.find((t) => t.name === options.template);
+        if (template) {
+          finalMessage = template.body;
+          console.log(`Using template: ${options.template}`);
+        } else
+          console.log(`Template "${options.template}" not found. Using default message.`);
+      }
+      const result = await withTimeout(smsClient.send({
+        to: phone,
+        message: finalMessage,
+        originationNumber
+      }), 30000);
+      if (result.messageId) {
+        console.log("\u2705 SMS sent successfully!");
+        console.log(`   Message ID: ${result.messageId}`);
+        if (originationNumber)
+          console.log(`   From: ${originationNumber}`);
+      } else
+        console.log("\u274C SMS send failed");
+    } catch (error) {
+      console.error("Error sending SMS:", getErrorMessage(error));
+      if (getErrorMessage(error).includes("not found") || getErrorMessage(error).includes("No phone")) {
+        console.log(`
+\uD83D\uDCA1 No origination phone number available.`);
+        console.log("   Run `buddy sms:setup` to provision a phone number.");
+      } else if (getErrorMessage(error).includes("not authorized"))
+        console.log(`
+\uD83D\uDCA1 Make sure your AWS account has SMS permissions.`);
+      else if (getErrorMessage(error).includes("sandbox"))
+        console.log("\n\uD83D\uDCA1 Your account is in SMS sandbox. Run `buddy sms:setup` to request production access.");
+      else if (getErrorMessage(error).includes("PENDING")) {
+        console.log(`
+\uD83D\uDCA1 Phone number is still pending verification (24-72 hours for toll-free).`);
+        console.log("   Run `buddy sms:status` to check current status.");
+      }
+    }
+    process.exit(0);
+  });
+  buddy.command("sms:setup", descriptions.setup).option("--dry-run", "Show what would be done without making changes").action(async (options) => {
+    console.log(`
+\uD83D\uDCF1 SMS Service Setup
+`);
+    loadAwsCredentials();
+    try {
+      const smsConfig = await import("@stacksjs/config").then((m) => m.config?.sms);
+      if (!smsConfig?.enabled) {
+        console.log("SMS is disabled in config/sms.ts");
+        console.log(`
+To enable SMS:`);
+        console.log("1. Edit config/sms.ts and set enabled: true");
+        console.log("2. Run `buddy sms:setup` again");
+        process.exit(0);
+        return;
+      }
+      if (options.dryRun) {
+        console.log("[Dry Run] Would set up SMS infrastructure with config:");
+        console.log(`  Provider: ${smsConfig.provider}`);
+        console.log(`  Country: ${smsConfig.defaultCountryCode}`);
+        console.log(`  Message Type: ${smsConfig.messageType}`);
+        console.log(`  Monthly Limit: $${smsConfig.maxSpendPerMonth || 1}`);
+        console.log(`  Two-Way: ${smsConfig.twoWay?.enabled ? "Enabled" : "Disabled"}`);
+        console.log(`  Inbox: ${smsConfig.inbox?.enabled ? "Enabled" : "Disabled"}`);
+        process.exit(0);
+        return;
+      }
+      console.log(`Setting up SMS infrastructure...
+`);
+      const { createSmsInfrastructure } = await import("@stacksjs/ts-cloud"), result = await withTimeout(createSmsInfrastructure({
+        enabled: smsConfig.enabled,
+        provider: smsConfig.provider || "pinpoint",
+        originationNumber: smsConfig.originationNumber,
+        defaultCountryCode: smsConfig.defaultCountryCode || "US",
+        messageType: smsConfig.messageType || "TRANSACTIONAL",
+        maxSpendPerMonth: smsConfig.maxSpendPerMonth,
+        inbox: smsConfig.inbox,
+        twoWay: smsConfig.twoWay,
+        optOut: smsConfig.optOut || { enabled: !0, keywords: ["STOP"] }
+      }), 120000);
+      if (result.success) {
+        console.log(`
+\u2705 SMS infrastructure setup complete!
+`);
+        if (result.phoneNumber)
+          console.log(`  Phone Number: ${result.phoneNumber} (${result.phoneNumberStatus})`);
+        if (result.twoWayTopicArn)
+          console.log(`  Two-Way Topic: ${result.twoWayTopicArn}`);
+        if (result.inboxBucket)
+          console.log(`  Inbox: s3://${result.inboxBucket}/${result.inboxPrefix}`);
+        console.log(`  Spending Limit: $${result.spendingLimit}/month`);
+        console.log(`  Sandbox Status: ${result.sandboxStatus}`);
+        if (result.supportCaseId) {
+          console.log(`
+  \uD83D\uDCCB Support Case: ${result.supportCaseId}`);
+          console.log("     A support ticket has been filed for sandbox exit.");
+        }
+        if (result.warnings.length > 0) {
+          console.log(`
+\u26A0\uFE0F  Warnings:`);
+          for (const warning of result.warnings)
+            console.log(`   - ${warning}`);
+        }
+        console.log(`
+\uD83D\uDCA1 Next steps:`);
+        console.log('   - Run `buddy sms:send +1234567890 "Test"` to send a test SMS');
+        console.log("   - Run `buddy sms:status` to check current status");
+      } else {
+        console.log(`
+\u274C SMS setup completed with errors:
+`);
+        for (const error of result.errors)
+          console.log(`   - ${error}`);
+      }
+    } catch (error) {
+      console.error("Error setting up SMS:", getErrorMessage(error));
+      if (getErrorMessage(error).includes("timeout")) {
+        console.log(`
+\uD83D\uDCA1 Setup timed out. Some operations may have completed.`);
+        console.log("   Run `buddy sms:status` to check current status.");
+      }
+    }
+    process.exit(0);
+  });
+  buddy.command("sms:add-phone <phone>", descriptions["add-phone"]).action(async (phone) => {
+    console.log(`
+\uD83D\uDCF1 Adding ${phone} to SMS sandbox...
+`);
+    loadAwsCredentials();
+    try {
+      const { PinpointSmsVoiceClient } = await import("@stacksjs/ts-cloud"), smsClient = new PinpointSmsVoiceClient(process.env.AWS_REGION || "us-east-1"), result = await withTimeout(smsClient.addSandboxPhone(phone), 30000);
+      if (result.status === "VERIFIED") {
+        console.log("\u2705 Phone is already verified!");
+        console.log(`   ID: ${result.verifiedDestinationNumberId}`);
+      } else if (result.status === "PENDING") {
+        console.log("\uD83D\uDCE8 Verification code sent to phone!");
+        console.log(`   ID: ${result.verifiedDestinationNumberId}`);
+        console.log(`
+\uD83D\uDCA1 Next step:`);
+        console.log(`   Run: buddy sms:verify ${result.verifiedDestinationNumberId} <code>`);
+        console.log("   Replace <code> with the 6-digit code you received");
+      } else {
+        console.log("\u2753 Unexpected status:", result.status);
+        console.log("   Message:", result.message);
+      }
+    } catch (error) {
+      console.error("Error adding phone:", getErrorMessage(error));
+      if (getErrorMessage(error).includes("already exists")) {
+        console.log(`
+\uD83D\uDCA1 Phone number may already be in the sandbox.`);
+        console.log("   Run `buddy sms:status` to check sandbox numbers.");
+      }
+    }
+    process.exit(0);
+  });
+  buddy.command("sms:verify <id> <code>", descriptions.verify).action(async (id, code) => {
+    console.log(`
+\uD83D\uDCF1 Verifying sandbox phone...
+`);
+    loadAwsCredentials();
+    try {
+      const { PinpointSmsVoiceClient } = await import("@stacksjs/ts-cloud"), smsClient = new PinpointSmsVoiceClient(process.env.AWS_REGION || "us-east-1"), result = await withTimeout(smsClient.verifySandboxPhone(id, code), 30000);
+      if (result.success) {
+        console.log("\u2705 Phone verified successfully!");
+        console.log(`   Phone: ${result.phoneNumber}`);
+        console.log(`
+\uD83D\uDCA1 You can now send SMS to this phone while in sandbox mode.`);
+        console.log(`   Run: buddy sms:send ${result.phoneNumber} "Test message"`);
+      } else {
+        console.log("\u274C Verification failed");
+        console.log(`   Error: ${result.message}`);
+        console.log(`
+\uD83D\uDCA1 Make sure you entered the correct 6-digit code.`);
+        console.log("   Run `buddy sms:add-phone <phone>` to resend the code.");
+      }
+    } catch (error) {
+      console.error("Error verifying phone:", getErrorMessage(error));
+    }
+    process.exit(0);
+  });
+  buddy.command("sms:sandbox-list", "List sandbox verified phone numbers").action(async () => {
+    console.log(`
+\uD83D\uDCF1 Sandbox Verified Numbers
+`);
+    loadAwsCredentials();
+    try {
+      const { PinpointSmsVoiceClient } = await import("@stacksjs/ts-cloud"), smsClient = new PinpointSmsVoiceClient(process.env.AWS_REGION || "us-east-1"), phones = await withTimeout(smsClient.listSandboxPhones(), 30000);
+      if (phones.length === 0) {
+        console.log("No verified sandbox numbers yet.");
+        console.log(`
+To add a phone:`);
+        console.log("  buddy sms:add-phone +1234567890");
+      } else
+        for (const phone of phones) {
+          const statusIcon = phone.status === "VERIFIED" ? "\u2705" : "\u23F3";
+          console.log(`  ${statusIcon} ${phone.phoneNumber} (${phone.status})`);
+          console.log(`     ID: ${phone.id}`);
+        }
+    } catch (error) {
+      console.error("Error listing sandbox phones:", getErrorMessage(error));
+    }
+    process.exit(0);
+  });
+}

package/dist/commands/stacks.d.ts

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

package/dist/commands/stacks.js

@@ -0,0 +1,69 @@
+import process from "node:process";
+import { installStack, listStacks, uninstallStack } from "@stacksjs/actions";
+import { intro, italic, onUnknownSubcommand, outro } from "@stacksjs/cli";
+import { log } from "@stacksjs/logging";
+import { ExitCode } from "@stacksjs/types";
+export function stacks(buddy) {
+  const descriptions = {
+    install: "Install a stack into your project",
+    uninstall: "Uninstall a stack from your project",
+    list: "List available and installed stacks",
+    force: "Force overwrite existing files",
+    dryRun: "Show what would be installed without making changes",
+    conflict: "Conflict resolution strategy: skip, overwrite, or backup",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("stack:install <name>", descriptions.install).option("--force", descriptions.force, { default: !1 }).option("--dry-run", descriptions.dryRun, { default: !1 }).option("--conflict <strategy>", descriptions.conflict, { default: "skip" }).option("--verbose", descriptions.verbose, { default: !1 }).example("buddy stack:install @stacksjs/blog").example("buddy stack:install blog --force").example("buddy stack:install blog --conflict backup --verbose").example("buddy stack:install blog --dry-run").action(async (name, options) => {
+    const perf = await intro("buddy stack:install");
+    if (!name) {
+      log.error("You need to specify a stack name.");
+      log.info("Example: buddy stack:install @stacksjs/blog");
+      process.exit(ExitCode.FatalError);
+    }
+    if (!await installStack({
+      name,
+      force: options.force,
+      dryRun: options.dryRun,
+      conflict: options.conflict || "skip",
+      verbose: options.verbose
+    }) && !options.dryRun) {
+      await outro("Failed to install stack", { startTime: perf, useSeconds: !0 });
+      process.exit(ExitCode.FatalError);
+    }
+    await outro(`Stack ${italic(name)} installed.`, { startTime: perf, useSeconds: !0 });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("stack:uninstall <name>", descriptions.uninstall).option("--force", descriptions.force, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).example("buddy stack:uninstall blog").example("buddy stack:uninstall blog --force").action(async (name, options) => {
+    const perf = await intro("buddy stack:uninstall");
+    if (!name) {
+      log.error("You need to specify a stack name.");
+      process.exit(ExitCode.FatalError);
+    }
+    if (!await uninstallStack({
+      name,
+      force: options.force,
+      verbose: options.verbose
+    })) {
+      await outro("Failed to uninstall stack", { startTime: perf, useSeconds: !0 });
+      process.exit(ExitCode.FatalError);
+    }
+    await outro(`Stack ${italic(name)} uninstalled.`, { startTime: perf, useSeconds: !0 });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("stack:list", descriptions.list).alias("stack:ls").example("buddy stack:list").action(async () => {
+    const perf = await intro("buddy stack:list"), entries = await listStacks();
+    if (entries.length === 0)
+      log.info("No stacks found. Install one with: buddy stack:install <name>");
+    else {
+      log.info(`Found ${entries.length} stack(s):`);
+      log.info("");
+      for (const entry of entries) {
+        const status = entry.installed ? "[installed]" : "[available]", desc = entry.description ? ` - ${entry.description}` : "", files = entry.fileCount ? ` (${entry.fileCount} files)` : "";
+        log.info(`  ${entry.name} ${italic(`v${entry.version}`)} ${status}${files}${desc}`);
+      }
+    }
+    await outro("", { startTime: perf, useSeconds: !0 });
+    process.exit(ExitCode.Success);
+  });
+  onUnknownSubcommand(buddy, "stack");
+}

package/dist/commands/telemetry.d.ts

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

package/dist/commands/telemetry.js

@@ -0,0 +1,74 @@
+import process from "node:process";
+import { bold, dim, green, intro, log, onUnknownSubcommand } from "@stacksjs/cli";
+const telemetry = {
+  async enable() {},
+  async disable() {},
+  async status() {
+    return {
+      enabled: !1,
+      doNotTrack: !!process.env.DO_NOT_TRACK,
+      eventsQueued: 0,
+      lastSent: null
+    };
+  }
+};
+export function telemetryCommand(buddy) {
+  buddy.command("telemetry", "Manage telemetry settings").option("--enable", "Enable telemetry").option("--disable", "Disable telemetry").option("--status", "Show telemetry status").example("buddy telemetry --status").example("buddy telemetry --enable").example("buddy telemetry --disable").action(async (options) => {
+    log.debug("Running `buddy telemetry` ...", options);
+    await intro("buddy telemetry");
+    try {
+      if (options.enable) {
+        await telemetry.enable();
+        log.success("Telemetry enabled");
+        log.info("");
+        log.info(dim("Anonymous usage statistics will be collected"));
+        log.info(dim("to help improve Buddy CLI."));
+        log.info("");
+        log.info(dim("You can disable telemetry anytime with:"));
+        log.info(dim("  buddy telemetry --disable"));
+        log.info("");
+        return;
+      }
+      if (options.disable) {
+        await telemetry.disable();
+        log.success("Telemetry disabled");
+        log.info("");
+        log.info(dim("No usage statistics will be collected."));
+        log.info("");
+        return;
+      }
+      const status = await telemetry.status();
+      log.info("");
+      log.info(green(bold("Telemetry Status")));
+      log.info(dim("\u2500".repeat(50)));
+      log.info("");
+      log.info(bold("Configuration:"));
+      log.info(`  Enabled:         ${dim(status.enabled ? "Yes" : "No")}`);
+      log.info(`  DO_NOT_TRACK:    ${dim(status.doNotTrack ? "Yes (respected)" : "No")}`);
+      log.info(`  Events queued:   ${dim(status.eventsQueued)}`);
+      if (status.lastSent) {
+        const lastSent = new Date(status.lastSent);
+        log.info(`  Last sent:       ${dim(lastSent.toLocaleString())}`);
+      } else
+        log.info(`  Last sent:       ${dim("Never")}`);
+      log.info("");
+      log.info(bold("Privacy:"));
+      log.info(`  ${dim("\u2022 Opt-in only (disabled by default)")}`);
+      log.info(`  ${dim("\u2022 No personal information collected")}`);
+      log.info(`  ${dim("\u2022 Anonymous user IDs only")}`);
+      log.info(`  ${dim("\u2022 Respects DO_NOT_TRACK environment variable")}`);
+      log.info("");
+      if (!status.enabled) {
+        log.info(dim("To enable telemetry: buddy telemetry --enable"));
+        log.info("");
+      } else {
+        log.info(dim("To disable telemetry: buddy telemetry --disable"));
+        log.info("");
+      }
+    } catch (error) {
+      log.error("Failed to manage telemetry:", error);
+      process.exit(1);
+    }
+  });
+  onUnknownSubcommand(buddy, "telemetry");
+}

package/dist/commands/test.d.ts

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

package/dist/commands/test.js

@@ -0,0 +1,130 @@
+import process from "node:process";
+import { runAction } from "@stacksjs/actions";
+import { intro, log, onUnknownSubcommand, outro } from "@stacksjs/cli";
+import { Action } from "@stacksjs/enums";
+import { projectPath } from "@stacksjs/path";
+import { ExitCode } from "@stacksjs/types";
+export 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",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("test", descriptions.command).option("-f, --feature", descriptions.feature, { default: !1 }).option("-u, --unit", descriptions.unit, { default: !1 }).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !0 }).action(async (options) => {
+    const perf = await intro("buddy test");
+    if (options.feature && options.unit) {
+      const result = await runAction(Action.Test, {
+        ...options,
+        cwd: projectPath()
+      });
+      if (result.isErr) {
+        await outro("While running `buddy test`, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+        process.exit(ExitCode.FatalError);
+      }
+    }
+    if (options.feature && !options.unit) {
+      log.info("Running Feature tests...");
+      const result = await runAction(Action.TestFeature, {
+        ...options,
+        cwd: projectPath()
+      });
+      if (result.isErr) {
+        await outro("While running `buddy test`, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+        process.exit(ExitCode.FatalError);
+      }
+    }
+    if (!options.feature && options.unit) {
+      log.info("Running Unit tests...");
+      const result = await runAction(Action.TestUnit, {
+        ...options,
+        cwd: projectPath()
+      });
+      if (result.isErr) {
+        await outro("While running `buddy test`, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+        process.exit(ExitCode.FatalError);
+      }
+    }
+    if (!options.feature && !options.unit) {
+      const result = await runAction(Action.Test, {
+        ...options,
+        cwd: projectPath()
+      });
+      if (result.isErr) {
+        await outro("While running `buddy test`, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+        process.exit(ExitCode.FatalError);
+      }
+    }
+    await outro("Finished running tests", {
+      startTime: perf,
+      useSeconds: !0
+    });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("test:unit", descriptions.unit).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    const perf = await intro("buddy test:unit"), result = await runAction(Action.TestUnit, {
+      ...options,
+      verbose: !0,
+      cwd: projectPath()
+    });
+    if (result.isErr) {
+      await outro("While running `buddy test:unit`, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Finished running unit tests", {
+      startTime: perf,
+      useSeconds: !0
+    });
+  });
+  buddy.command("test:feature", descriptions.feature).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    const perf = await intro("buddy test:feature"), result = await runAction(Action.TestFeature, {
+      ...options,
+      verbose: !0,
+      cwd: projectPath()
+    });
+    if (result.isErr) {
+      await outro("While running `buddy test:feature`, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Finished running feature tests", {
+      startTime: perf,
+      useSeconds: !0
+    });
+  });
+  buddy.command("test:ui", descriptions.command).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    const perf = await intro("buddy test:ui"), result = await runAction(Action.TestUi, {
+      ...options,
+      verbose: !0,
+      cwd: projectPath()
+    });
+    if (result.isErr) {
+      await outro("While running `buddy test:ui`, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Finished running tests in the browser", {
+      startTime: perf,
+      useSeconds: !0
+    });
+  });
+  buddy.command("test:types", descriptions.types).alias("typecheck").option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    const perf = await intro("buddy test:types"), result = await runAction(Action.Typecheck, {
+      ...options,
+      verbose: !0,
+      cwd: projectPath()
+    });
+    if (result.isErr) {
+      await outro("While running `buddy test:types`, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Finished running typecheck", {
+      startTime: perf,
+      useSeconds: !0
+    });
+  });
+  onUnknownSubcommand(buddy, "test");
+}

package/dist/commands/tinker.d.ts

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

package/dist/commands/tinker.js

@@ -0,0 +1,37 @@
+import process from "node:process";
+import { intro, log, onUnknownSubcommand, outro } from "@stacksjs/cli";
+import { ExitCode } from "@stacksjs/types";
+export function tinker(buddy) {
+  const descriptions = {
+    tinker: "Interactive REPL with Stacks framework preloaded",
+    eval: "Evaluate a single expression and exit",
+    print: "Evaluate, print, and exit",
+    noBanner: "Skip the welcome banner",
+    preload: "Additional modules to preload (comma-separated)",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("tinker", descriptions.tinker).option("-e, --eval [expression]", descriptions.eval, { default: "" }).option("--print [expression]", descriptions.print, { default: "" }).option("--no-banner", descriptions.noBanner, { default: !1 }).option("--preload [modules]", descriptions.preload, { default: "" }).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy tinker` ...", options);
+    const perf = await intro("buddy tinker");
+    try {
+      const { startTinker } = await import("@stacksjs/tinker"), preloadModules = typeof options.preload === "string" && options.preload ? options.preload.split(",").map((m) => m.trim()) : void 0;
+      if ((await startTinker({
+        eval: typeof options.eval === "string" && options.eval ? options.eval : void 0,
+        print: typeof options.print === "string" && options.print ? options.print : void 0,
+        banner: options.noBanner !== !0,
+        preload: preloadModules,
+        verbose: options.verbose === !0
+      })).exitCode !== 0) {
+        await outro("Tinker session ended with errors", { startTime: perf, useSeconds: !0 });
+        process.exit(ExitCode.FatalError);
+      }
+      await outro("Tinker session ended.", { startTime: perf, useSeconds: !0 });
+      process.exit(ExitCode.Success);
+    } catch (error) {
+      await outro("While running the tinker command, there was an issue", { startTime: perf, useSeconds: !0 }, error instanceof Error ? error : void 0);
+      process.exit(ExitCode.FatalError);
+    }
+  });
+  onUnknownSubcommand(buddy, "tinker");
+}

package/dist/commands/types.d.ts

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