stoatx 0.2.0 → 0.3.0

package/dist/index.js

@@ -0,0 +1,791 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Client: () => Client,
+  CommandRegistry: () => CommandRegistry,
+  Guard: () => Guard,
+  METADATA_KEYS: () => METADATA_KEYS,
+  On: () => On,
+  Once: () => Once,
+  SimpleCommand: () => SimpleCommand,
+  Stoat: () => Stoat,
+  buildSimpleCommandMetadata: () => buildSimpleCommandMetadata,
+  getEventsMetadata: () => getEventsMetadata,
+  getGuards: () => getGuards,
+  getSimpleCommands: () => getSimpleCommands,
+  isStoatClass: () => isStoatClass
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/decorators/Stoat.ts
+var import_reflect_metadata = require("reflect-metadata");
+
+// src/decorators/keys.ts
+var METADATA_KEYS = {
+  IS_STOAT_CLASS: /* @__PURE__ */ Symbol("stoatx:stoat:isClass"),
+  SIMPLE_COMMANDS: /* @__PURE__ */ Symbol("stoatx:stoat:simpleCommands"),
+  GUARDS: "stoatx:command:guards",
+  EVENTS: /* @__PURE__ */ Symbol("stoatx:stoat:events")
+};
+
+// src/decorators/store.ts
+var DecoratorStore = class _DecoratorStore {
+  constructor() {
+    /** Stoat classes with their SimpleCommand methods */
+    this.stoatClasses = /* @__PURE__ */ new Map();
+    /** Registered commands from @Stoat/@SimpleCommand decorators */
+    this.commands = [];
+    /** Whether the store has been initialized */
+    this.initialized = false;
+  }
+  static getInstance() {
+    if (!_DecoratorStore.instance) {
+      _DecoratorStore.instance = new _DecoratorStore();
+    }
+    return _DecoratorStore.instance;
+  }
+  /**
+   * Register a @Stoat decorated class
+   */
+  registerStoatClass(classConstructor) {
+    if (!this.stoatClasses.has(classConstructor)) {
+      const instance = new classConstructor();
+      this.stoatClasses.set(classConstructor, instance);
+    }
+  }
+  /**
+   * Get all registered Stoat classes with their instances
+   */
+  getStoatClasses() {
+    return this.stoatClasses;
+  }
+  /**
+   * Add a registered command
+   */
+  addCommand(command) {
+    this.commands.push(command);
+  }
+  /**
+   * Get all registered commands
+   */
+  getCommands() {
+    return this.commands;
+  }
+  /**
+   * Clear all registered classes (useful for testing)
+   */
+  clear() {
+    this.stoatClasses.clear();
+    this.commands = [];
+    this.initialized = false;
+  }
+  /**
+   * Mark as initialized
+   */
+  markInitialized() {
+    this.initialized = true;
+  }
+  /**
+   * Check if initialized
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+};
+var decoratorStore = DecoratorStore.getInstance();
+
+// src/decorators/Stoat.ts
+function Stoat() {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEYS.IS_STOAT_CLASS, true, target);
+    decoratorStore.registerStoatClass(target);
+  };
+}
+function isStoatClass(target) {
+  return Reflect.getMetadata(METADATA_KEYS.IS_STOAT_CLASS, target) === true;
+}
+
+// src/decorators/SimpleCommand.ts
+var import_reflect_metadata2 = require("reflect-metadata");
+function SimpleCommand(options = {}) {
+  return (target, propertyKey, descriptor) => {
+    const constructor = target.constructor;
+    const existingCommands = Reflect.getMetadata(METADATA_KEYS.SIMPLE_COMMANDS, constructor) || [];
+    existingCommands.push({
+      methodName: String(propertyKey),
+      options
+    });
+    Reflect.defineMetadata(METADATA_KEYS.SIMPLE_COMMANDS, existingCommands, constructor);
+    return descriptor;
+  };
+}
+function getSimpleCommands(target) {
+  return Reflect.getMetadata(METADATA_KEYS.SIMPLE_COMMANDS, target) || [];
+}
+
+// src/decorators/Guard.ts
+var import_reflect_metadata3 = require("reflect-metadata");
+function Guard(guardClass) {
+  return (target) => {
+    const existingGuards = Reflect.getMetadata(METADATA_KEYS.GUARDS, target) || [];
+    existingGuards.push(guardClass);
+    Reflect.defineMetadata(METADATA_KEYS.GUARDS, existingGuards, target);
+  };
+}
+function getGuards(target) {
+  return Reflect.getMetadata(METADATA_KEYS.GUARDS, target) || [];
+}
+
+// src/decorators/Events.ts
+var import_reflect_metadata4 = require("reflect-metadata");
+function createEventDecorator(event, type) {
+  return (target, propertyKey, descriptor) => {
+    const constructor = target.constructor;
+    const existingEvents = Reflect.getMetadata(METADATA_KEYS.EVENTS, constructor) || [];
+    existingEvents.push({
+      methodName: String(propertyKey),
+      event,
+      type
+    });
+    Reflect.defineMetadata(METADATA_KEYS.EVENTS, existingEvents, constructor);
+    return descriptor;
+  };
+}
+function On(event) {
+  return createEventDecorator(event, "on");
+}
+function Once(event) {
+  return createEventDecorator(event, "once");
+}
+function getEventsMetadata(target) {
+  return Reflect.getMetadata(METADATA_KEYS.EVENTS, target) || [];
+}
+
+// src/decorators/utils.ts
+function buildSimpleCommandMetadata(options, methodName, category) {
+  return {
+    name: options.name ?? methodName.toLowerCase(),
+    description: options.description ?? "No description provided",
+    aliases: options.aliases ?? [],
+    permissions: options.permissions ?? [],
+    category: options.category ?? category ?? "uncategorized",
+    cooldown: options.cooldown ?? 0,
+    nsfw: options.nsfw ?? false,
+    ownerOnly: options.ownerOnly ?? false
+  };
+}
+
+// src/registry.ts
+var path = __toESM(require("path"));
+var fs = __toESM(require("fs/promises"));
+var import_node_url = require("url");
+var import_tinyglobby = require("tinyglobby");
+var _CommandRegistry = class _CommandRegistry {
+  constructor(extensions = [".js", ".mjs", ".cjs"]) {
+    this.commands = /* @__PURE__ */ new Map();
+    this.aliases = /* @__PURE__ */ new Map();
+    this.registeredEvents = [];
+    this.processedStoatClasses = /* @__PURE__ */ new Set();
+    this.extensions = extensions;
+  }
+  /**
+   * Get the number of registered commands
+   */
+  get size() {
+    return this.commands.size;
+  }
+  /**
+   * Load commands from a directory using glob pattern matching
+   */
+  async loadFromDirectory(directory) {
+    const patterns = this.extensions.map((ext) => path.join(directory, "**", `*${ext}`).replace(/\\/g, "/"));
+    for (const pattern of patterns) {
+      const files = await (0, import_tinyglobby.glob)(pattern, {
+        ignore: ["**/*.d.ts", "**/*.test.ts", "**/*.spec.ts"],
+        absolute: true
+      });
+      for (const file of files) {
+        await this.loadFile(file, directory);
+      }
+    }
+    console.log(`[Stoatx] Loaded ${this.commands.size} command(s) and ${this.registeredEvents.length} event(s)`);
+  }
+  /**
+   * Auto-discover command files across one or more roots.
+   */
+  async autoDiscover(options = {}) {
+    const roots = options.roots?.length ? options.roots : [process.cwd()];
+    const includePatterns = options.include?.length ? options.include : this.getDefaultAutoDiscoveryPatterns();
+    const patterns = roots.flatMap(
+      (root) => includePatterns.map((pattern) => path.join(root, pattern).replace(/\\/g, "/"))
+    );
+    const files = await (0, import_tinyglobby.glob)(patterns, {
+      ignore: [..._CommandRegistry.DEFAULT_AUTO_DISCOVERY_IGNORES, ...options.ignore ?? []],
+      absolute: true
+    });
+    const uniqueFiles = [...new Set(files)];
+    let candidateFiles = 0;
+    for (const file of uniqueFiles) {
+      if (!await this.isLikelyCommandModule(file)) {
+        continue;
+      }
+      candidateFiles++;
+      const baseDir = roots.find((root) => {
+        const relative2 = path.relative(root, file);
+        return relative2 && !relative2.startsWith("..") && !path.isAbsolute(relative2);
+      }) ?? roots[0];
+      await this.loadFile(file, baseDir);
+    }
+    console.log(`[Stoatx] Loaded ${this.commands.size} command(s) and ${this.registeredEvents.length} event(s)`);
+  }
+  getDefaultAutoDiscoveryPatterns() {
+    return this.extensions.map((ext) => `**/*${ext}`);
+  }
+  async isLikelyCommandModule(filePath) {
+    try {
+      const source = await fs.readFile(filePath, "utf8");
+      return source.includes("Stoat") || source.includes("SimpleCommand") || source.includes("Command") || source.includes("stoatx:command");
+    } catch {
+      return true;
+    }
+  }
+  /**
+   * Register a command instance
+   */
+  register(instance, metadata, classConstructor, methodName) {
+    const name = metadata.name.toLowerCase();
+    if (this.commands.has(name)) {
+      console.warn(`[Stoatx] Duplicate command name: ${name}. Skipping...`);
+      return;
+    }
+    this.validateGuards(classConstructor, metadata.name);
+    this.commands.set(name, { instance, metadata, methodName, classConstructor });
+    for (const alias of metadata.aliases) {
+      const aliasLower = alias.toLowerCase();
+      if (this.aliases.has(aliasLower) || this.commands.has(aliasLower)) {
+        console.warn(`[Stoatx] Duplicate alias: ${aliasLower}. Skipping...`);
+        continue;
+      }
+      this.aliases.set(aliasLower, name);
+    }
+  }
+  /**
+   * Get a command by name or alias
+   */
+  get(name) {
+    const lowerName = name.toLowerCase();
+    const resolvedName = this.aliases.get(lowerName) ?? lowerName;
+    return this.commands.get(resolvedName);
+  }
+  /**
+   * Check if a command exists
+   */
+  has(name) {
+    const lowerName = name.toLowerCase();
+    return this.commands.has(lowerName) || this.aliases.has(lowerName);
+  }
+  /**
+   * Get all registered commands
+   */
+  getAll() {
+    return Array.from(this.commands.values());
+  }
+  /**
+   * Get all command metadata
+   */
+  getAllMetadata() {
+    return this.getAll().map((c) => c.metadata);
+  }
+  /**
+   * Get all registered events
+   */
+  getEvents() {
+    return this.registeredEvents;
+  }
+  /**
+   * Get commands grouped by category
+   */
+  getByCategory() {
+    const categories = /* @__PURE__ */ new Map();
+    for (const cmd of this.commands.values()) {
+      const category = cmd.metadata.category;
+      const existing = categories.get(category) ?? [];
+      existing.push(cmd);
+      categories.set(category, existing);
+    }
+    return categories;
+  }
+  /**
+   * Clear all commands
+   */
+  clear() {
+    this.commands.clear();
+    this.aliases.clear();
+    this.registeredEvents.length = 0;
+    this.processedStoatClasses.clear();
+  }
+  /**
+   * Iterate over commands
+   */
+  [Symbol.iterator]() {
+    return this.commands.entries();
+  }
+  /**
+   * Iterate over command values
+   */
+  values() {
+    return this.commands.values();
+  }
+  /**
+   * Iterate over command names
+   */
+  keys() {
+    return this.commands.keys();
+  }
+  /**
+   * Validate that all guards on a command implement the required methods
+   * @param commandClass
+   * @param commandName
+   * @private
+   */
+  validateGuards(commandClass, commandName) {
+    const guards = Reflect.getMetadata("stoatx:command:guards", commandClass) || [];
+    for (const GuardClass of guards) {
+      const guardInstance = new GuardClass();
+      if (typeof guardInstance.run !== "function") {
+        console.error(
+          `[Stoatx] FATAL: Guard "${GuardClass.name}" on command "${commandName}" does not have a run() method.`
+        );
+        process.exit(1);
+      }
+      if (typeof guardInstance.guardFail !== "function") {
+        console.error(
+          `[Stoatx] FATAL: Guard "${GuardClass.name}" on command "${commandName}" does not have a guardFail() method.`
+        );
+        console.error(`[Stoatx] All guards must implement guardFail() to handle failed checks.`);
+        process.exit(1);
+      }
+    }
+  }
+  /**
+   * Load commands from a single file
+   */
+  async loadFile(filePath, baseDir) {
+    try {
+      const knownStoatClasses = new Set(decoratorStore.getStoatClasses().keys());
+      const fileUrl = (0, import_node_url.pathToFileURL)(filePath).href;
+      await import(fileUrl);
+      const allStoatClasses = decoratorStore.getStoatClasses();
+      for (const [stoatClass, stoatInstance] of allStoatClasses.entries()) {
+        if (knownStoatClasses.has(stoatClass) || this.processedStoatClasses.has(stoatClass)) {
+          continue;
+        }
+        this.registerStoatClassCommands(stoatClass, stoatInstance, filePath, baseDir);
+      }
+    } catch (error) {
+      console.error(`[Stoatx] Failed to load command file: ${filePath}`, error);
+    }
+  }
+  registerStoatClassCommands(stoatClass, instance, filePath, baseDir) {
+    const simpleCommands = getSimpleCommands(stoatClass);
+    const events = getEventsMetadata(stoatClass);
+    const category = this.getCategoryFromPath(filePath, baseDir);
+    if (simpleCommands.length === 0 && events.length === 0) {
+      console.warn(
+        `[Stoatx] Class ${stoatClass.name} is decorated with @Stoat but has no @SimpleCommand, @On or @Once methods. Skipping...`
+      );
+      this.processedStoatClasses.add(stoatClass);
+      return;
+    }
+    for (const cmdDef of simpleCommands) {
+      const method = instance[cmdDef.methodName];
+      if (typeof method !== "function") {
+        console.warn(`[Stoatx] Method ${cmdDef.methodName} not found on ${stoatClass.name}. Skipping...`);
+        continue;
+      }
+      const metadata = buildSimpleCommandMetadata(cmdDef.options, cmdDef.methodName, category);
+      this.register(instance, metadata, stoatClass, cmdDef.methodName);
+    }
+    for (const eventDef of events) {
+      const method = instance[eventDef.methodName];
+      if (typeof method !== "function") {
+        console.warn(`[Stoatx] Method ${eventDef.methodName} not found on ${stoatClass.name}. Skipping...`);
+        continue;
+      }
+      this.registeredEvents.push({
+        instance,
+        methodName: eventDef.methodName,
+        event: eventDef.event,
+        type: eventDef.type
+      });
+    }
+    this.processedStoatClasses.add(stoatClass);
+  }
+  /**
+   * Derive category from file path relative to base directory
+   */
+  getCategoryFromPath(filePath, baseDir) {
+    const relative2 = path.relative(baseDir, filePath);
+    const parts = relative2.split(path.sep);
+    if (parts.length > 1) {
+      return parts[0];
+    }
+    return void 0;
+  }
+};
+_CommandRegistry.DEFAULT_AUTO_DISCOVERY_IGNORES = [
+  "**/node_modules/**",
+  "**/.git/**",
+  "**/*.d.ts",
+  "**/*.test.*",
+  "**/*.spec.*"
+];
+var CommandRegistry = _CommandRegistry;
+
+// src/handler.ts
+var import_reflect_metadata5 = require("reflect-metadata");
+var import_stoat = require("stoat.js");
+var Client = class extends import_stoat.Client {
+  constructor(options) {
+    super();
+    this.handler = new StoatxHandler({ ...options, client: this });
+    this.on("messageCreate", async (message) => {
+      await this.handler.handle(message);
+    });
+  }
+  /**
+   * Initialize the StoatxHandler commands
+   */
+  async initCommands() {
+    await this.handler.init();
+  }
+};
+var StoatxHandler = class {
+  constructor(options) {
+    this.cooldowns = /* @__PURE__ */ new Map();
+    this.client = options.client;
+    this.commandsDir = options.commandsDir;
+    this.discoveryOptions = options.discovery;
+    this.prefixResolver = options.prefix;
+    this.owners = new Set(options.owners ?? []);
+    this.registry = new CommandRegistry(options.extensions);
+    this.disableMentionPrefix = options.disableMentionPrefix ?? false;
+  }
+  /**
+   * Initialize the handler - load all commands
+   */
+  async init() {
+    if (this.commandsDir) {
+      await this.registry.loadFromDirectory(this.commandsDir);
+    } else {
+      await this.registry.autoDiscover(this.discoveryOptions);
+    }
+    this.attachEvents();
+  }
+  /**
+   * Attach registered events to the client
+   */
+  attachEvents() {
+    const events = this.registry.getEvents();
+    for (const eventDef of events) {
+      const handler = async (...args) => {
+        try {
+          await eventDef.instance[eventDef.methodName](...args, this.client);
+        } catch (error) {
+          console.error(
+            `[Stoatx] Event Handler Error in @${eventDef.type === "on" ? "On" : "Once"}('${eventDef.event}'):`,
+            error
+          );
+        }
+      };
+      if (eventDef.type === "once") {
+        this.client.once(eventDef.event, handler);
+      } else {
+        this.client.on(eventDef.event, handler);
+      }
+    }
+  }
+  /**
+   * Parse a raw message into command context
+   */
+  async parseMessage(rawContent, message, meta) {
+    const prefix = await this.resolvePrefix(meta.serverId);
+    let usedPrefix = prefix;
+    let withoutPrefix = "";
+    if (rawContent.startsWith(prefix)) {
+      withoutPrefix = rawContent.slice(prefix.length).trim();
+      usedPrefix = prefix;
+    } else if (!this.disableMentionPrefix && rawContent.match(/^<@!?[\w]+>/)) {
+      const mentionMatch = rawContent.match(/^<@!?([\w]+)>\s*/);
+      if (mentionMatch) {
+        const mentionedId = mentionMatch[1];
+        const botId = this.client.user?.id;
+        if (botId && mentionedId === botId) {
+          usedPrefix = mentionMatch[0];
+          withoutPrefix = rawContent.slice(mentionMatch[0].length).trim();
+        } else {
+        }
+      }
+    }
+    if (!withoutPrefix) {
+      return null;
+    }
+    const [commandName, ...args] = withoutPrefix.split(/\s+/);
+    if (!commandName) {
+      return null;
+    }
+    return {
+      client: this.client,
+      content: rawContent,
+      authorId: meta.authorId,
+      channelId: meta.channelId,
+      serverId: meta.serverId,
+      args,
+      prefix: usedPrefix,
+      commandName: commandName.toLowerCase(),
+      reply: meta.reply,
+      message
+    };
+  }
+  /**
+   * Handle a message object using the configured message adapter
+   *
+   * @example
+   * ```ts
+   * // With message adapter configured
+   * client.on('messageCreate', (message) => {
+   *   handler.handle(message);
+   * });
+   * ```
+   */
+  async handle(message) {
+    if (!message.channel || !message.author) {
+      return false;
+    }
+    if (message.author.bot) {
+      return false;
+    }
+    const rawContent = message.content;
+    const authorId = message.author.id;
+    const channelId = message.channel.id;
+    const serverId = message.server?.id;
+    const reply = async (content) => {
+      await message.channel.sendMessage(content);
+    };
+    return this.handleMessage(rawContent, message, {
+      authorId,
+      channelId,
+      serverId,
+      reply
+    });
+  }
+  /**
+   * Handle a raw message string with metadata
+   *
+   * @example
+   * ```ts
+   * // Manual usage without message adapter
+   * client.on('messageCreate', (message) => {
+   *   handler.handleMessage(message.content, message, {
+   *     authorId: message.author.id,
+   *     channelId: message.channel.id,
+   *     serverId: message.server?.id,
+   *     reply: (content) => message.channel.sendMessage(content),
+   *   });
+   * });
+   * ```
+   */
+  async handleMessage(rawContent, message, meta) {
+    const ctx = await this.parseMessage(rawContent, message, meta);
+    if (!ctx) {
+      return false;
+    }
+    return this.execute(ctx);
+  }
+  /**
+   * Execute a command with the given context
+   */
+  async execute(ctx) {
+    const registered = this.registry.get(ctx.commandName);
+    if (!registered) {
+      return false;
+    }
+    const { instance, metadata, methodName, classConstructor } = registered;
+    if (metadata.ownerOnly && !this.owners.has(ctx.authorId)) {
+      await ctx.reply("This command is owner-only.");
+      return false;
+    }
+    const guards = Reflect.getMetadata("stoatx:command:guards", classConstructor) || [];
+    for (const guardClass of guards) {
+      const guardInstance = new guardClass();
+      if (typeof guardInstance.run === "function") {
+        const guardResult = await guardInstance.run(ctx);
+        if (!guardResult) {
+          if (typeof guardInstance.guardFail === "function") {
+            await guardInstance.guardFail(ctx);
+          } else {
+            console.error("[Stoatx] Guard check failed but no guardFail method defined on", guardClass.name);
+          }
+          return false;
+        }
+      }
+    }
+    if (!this.checkCooldown(ctx.authorId, metadata)) {
+      const remaining = this.getRemainingCooldown(ctx.authorId, metadata);
+      if (typeof instance.onCooldown === "function") {
+        await instance.onCooldown(ctx, remaining);
+      } else {
+        await ctx.reply(`Please wait ${(remaining / 1e3).toFixed(1)} seconds before using this command again.`);
+      }
+      return false;
+    }
+    try {
+      await instance[methodName](ctx);
+      if (metadata.cooldown > 0) {
+        this.setCooldown(ctx.authorId, metadata);
+      }
+      return true;
+    } catch (error) {
+      if (typeof instance.onError === "function") {
+        await instance.onError(ctx, error);
+      } else {
+        console.error(`[Stoatx] Error in command ${metadata.name}:`, error);
+        await ctx.reply(`An error occurred: ${error.message}`);
+      }
+      return false;
+    }
+  }
+  /**
+   * Get the command registry
+   */
+  getRegistry() {
+    return this.registry;
+  }
+  /**
+   * Get a command by name or alias
+   */
+  getCommand(name) {
+    return this.registry.get(name);
+  }
+  /**
+   * Get all commands
+   */
+  getCommands() {
+    return this.registry.getAll();
+  }
+  /**
+   * Reload all commands
+   */
+  async reload() {
+    this.registry.clear();
+    this.cooldowns.clear();
+    if (this.commandsDir) {
+      await this.registry.loadFromDirectory(this.commandsDir);
+      return;
+    }
+    await this.registry.autoDiscover(this.discoveryOptions);
+  }
+  /**
+   * Check if a user is an owner
+   */
+  isOwner(userId) {
+    return this.owners.has(userId);
+  }
+  /**
+   * Add an owner
+   */
+  addOwner(userId) {
+    this.owners.add(userId);
+  }
+  /**
+   * Remove an owner
+   */
+  removeOwner(userId) {
+    this.owners.delete(userId);
+  }
+  /**
+   * Resolve the prefix for a context
+   */
+  async resolvePrefix(serverId) {
+    if (typeof this.prefixResolver === "function") {
+      return this.prefixResolver({ serverId });
+    }
+    return this.prefixResolver;
+  }
+  /**
+   * Check if user is on cooldown
+   */
+  checkCooldown(userId, metadata) {
+    if (metadata.cooldown <= 0) return true;
+    const commandCooldowns = this.cooldowns.get(metadata.name);
+    if (!commandCooldowns) return true;
+    const userCooldown = commandCooldowns.get(userId);
+    if (!userCooldown) return true;
+    return Date.now() >= userCooldown;
+  }
+  /**
+   * Get remaining cooldown time in ms
+   */
+  getRemainingCooldown(userId, metadata) {
+    const commandCooldowns = this.cooldowns.get(metadata.name);
+    if (!commandCooldowns) return 0;
+    const userCooldown = commandCooldowns.get(userId);
+    if (!userCooldown) return 0;
+    return Math.max(0, userCooldown - Date.now());
+  }
+  /**
+   * Set cooldown for a user
+   */
+  setCooldown(userId, metadata) {
+    if (!this.cooldowns.has(metadata.name)) {
+      this.cooldowns.set(metadata.name, /* @__PURE__ */ new Map());
+    }
+    const commandCooldowns = this.cooldowns.get(metadata.name);
+    commandCooldowns.set(userId, Date.now() + metadata.cooldown);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Client,
+  CommandRegistry,
+  Guard,
+  METADATA_KEYS,
+  On,
+  Once,
+  SimpleCommand,
+  Stoat,
+  buildSimpleCommandMetadata,
+  getEventsMetadata,
+  getGuards,
+  getSimpleCommands,
+  isStoatClass
+});