@marshmallow-stoat/mally 0.1.2 → 0.2.0

package/dist/index.js

@@ -30,51 +30,100 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  BaseCommand: () => BaseCommand,
-  Command: () => Command,
   CommandRegistry: () => CommandRegistry,
   Guard: () => Guard,
   METADATA_KEYS: () => METADATA_KEYS,
   MallyHandler: () => MallyHandler,
   SimpleCommand: () => SimpleCommand,
   Stoat: () => Stoat,
-  buildCommandMetadata: () => buildCommandMetadata,
   buildSimpleCommandMetadata: () => buildSimpleCommandMetadata,
-  getCommandOptions: () => getCommandOptions,
   getGuards: () => getGuards,
   getSimpleCommands: () => getSimpleCommands,
-  isCommand: () => isCommand,
   isStoatClass: () => isStoatClass
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/types.ts
-var BaseCommand = class {
-  /**
-   * Optional: Called when an error occurs during command execution.
-   * Override this method to provide custom error handling.
-   */
-  async onError(ctx, error) {
-    await ctx.reply(`An error occurred: ${error.message}`);
-  }
-};
-
 // src/decorators/Stoat.ts
 var import_reflect_metadata = require("reflect-metadata");
 
 // src/decorators/keys.ts
 var METADATA_KEYS = {
-  COMMAND_OPTIONS: /* @__PURE__ */ Symbol("mally:command:options"),
-  IS_COMMAND: /* @__PURE__ */ Symbol("mally:command:isCommand"),
   IS_STOAT_CLASS: /* @__PURE__ */ Symbol("mally:stoat:isClass"),
   SIMPLE_COMMANDS: /* @__PURE__ */ Symbol("mally:stoat:simpleCommands"),
   GUARDS: "mally:command:guards"
 };
 
+// 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) {
@@ -99,37 +148,8 @@ function getSimpleCommands(target) {
   return Reflect.getMetadata(METADATA_KEYS.SIMPLE_COMMANDS, target) || [];
 }
 
-// src/decorators/Command.ts
-var import_reflect_metadata3 = require("reflect-metadata");
-function Command(options = {}) {
-  return (target) => {
-    Reflect.defineMetadata(METADATA_KEYS.IS_COMMAND, true, target);
-    Reflect.defineMetadata(METADATA_KEYS.COMMAND_OPTIONS, options, target);
-  };
-}
-function isCommand(target) {
-  return Reflect.getMetadata(METADATA_KEYS.IS_COMMAND, target) === true;
-}
-function getCommandOptions(target) {
-  return Reflect.getMetadata(METADATA_KEYS.COMMAND_OPTIONS, target);
-}
-function buildCommandMetadata(target, options, category) {
-  const className = target.name;
-  const derivedName = className.replace(/Command$/i, "").toLowerCase();
-  return {
-    name: options.name ?? derivedName,
-    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/decorators/Guard.ts
-var import_reflect_metadata4 = require("reflect-metadata");
+var import_reflect_metadata3 = require("reflect-metadata");
 function Guard(guardClass) {
   return (target) => {
     const existingGuards = Reflect.getMetadata(METADATA_KEYS.GUARDS, target) || [];
@@ -157,12 +177,14 @@ function buildSimpleCommandMetadata(options, methodName, category) {
 
 // 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 {
-  constructor(extensions = [".js", ".ts"]) {
+var _CommandRegistry = class _CommandRegistry {
+  constructor(extensions = [".js", ".mjs", ".cjs"]) {
     this.commands = /* @__PURE__ */ new Map();
     this.aliases = /* @__PURE__ */ new Map();
+    this.processedStoatClasses = /* @__PURE__ */ new Set();
     this.extensions = extensions;
   }
   /**
@@ -187,6 +209,45 @@ var CommandRegistry = class {
     }
     console.log(`[Mally] Loaded ${this.commands.size} command(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(`[Mally] Auto-discovered ${candidateFiles} candidate file(s), loaded ${this.commands.size} command(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("mally:command");
+    } catch {
+      return true;
+    }
+  }
   /**
    * Register a command instance
    */
@@ -197,9 +258,6 @@ var CommandRegistry = class {
       return;
     }
     this.validateGuards(classConstructor, metadata.name);
-    if (!methodName) {
-      this.validateCooldown(instance, metadata);
-    }
     this.commands.set(name, { instance, metadata, methodName, classConstructor });
     for (const alias of metadata.aliases) {
       const aliasLower = alias.toLowerCase();
@@ -256,6 +314,7 @@ var CommandRegistry = class {
   clear() {
     this.commands.clear();
     this.aliases.clear();
+    this.processedStoatClasses.clear();
   }
   /**
    * Iterate over commands
@@ -300,77 +359,46 @@ var CommandRegistry = class {
       }
     }
   }
-  /**
-   * Validate that commands with cooldowns implement the onCooldown method
-   * @param instance
-   * @param metadata
-   * @private
-   */
-  validateCooldown(instance, metadata) {
-    if (metadata.cooldown > 0 && typeof instance.onCooldown !== "function") {
-      console.error(
-        `[Mally] FATAL: Command "${metadata.name}" has a cooldown of ${metadata.cooldown}ms but does not implement onCooldown() method.`
-      );
-      console.error(
-        `[Mally] Commands with cooldowns must implement onCooldown(ctx, remaining) to handle cooldown messages.`
-      );
-      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;
-      const module2 = await import(fileUrl);
-      for (const exportKey of Object.keys(module2)) {
-        const exported = module2[exportKey];
-        if (typeof exported !== "function") {
-          continue;
-        }
-        if (isStoatClass(exported)) {
-          const instance2 = new exported();
-          const simpleCommands = getSimpleCommands(exported);
-          const category2 = this.getCategoryFromPath(filePath, baseDir);
-          if (simpleCommands.length === 0) {
-            console.warn(
-              `[Mally] Class ${exported.name} is decorated with @Stoat but has no @SimpleCommand methods. Skipping...`
-            );
-            continue;
-          }
-          for (const cmdDef of simpleCommands) {
-            const method = instance2[cmdDef.methodName];
-            if (typeof method !== "function") {
-              console.warn(`[Mally] Method ${cmdDef.methodName} not found on ${exported.name}. Skipping...`);
-              continue;
-            }
-            const metadata2 = buildSimpleCommandMetadata(cmdDef.options, cmdDef.methodName, category2);
-            this.register(instance2, metadata2, exported, cmdDef.methodName);
-          }
-          continue;
-        }
-        if (!isCommand(exported)) {
-          continue;
-        }
-        const options = getCommandOptions(exported);
-        if (!options) continue;
-        const instance = new exported();
-        if (typeof instance.run !== "function") {
-          console.warn(
-            `[Mally] Class ${exported.name} is decorated with @Command but does not implement run() method. Skipping...`
-          );
+      await import(fileUrl);
+      const allStoatClasses = decoratorStore.getStoatClasses();
+      for (const [stoatClass, stoatInstance] of allStoatClasses.entries()) {
+        if (knownStoatClasses.has(stoatClass) || this.processedStoatClasses.has(stoatClass)) {
           continue;
         }
-        const category = this.getCategoryFromPath(filePath, baseDir);
-        const metadata = buildCommandMetadata(exported, options, category);
-        instance.metadata = metadata;
-        this.register(instance, metadata, exported);
+        this.registerStoatClassCommands(stoatClass, stoatInstance, filePath, baseDir);
       }
     } catch (error) {
       console.error(`[Mally] Failed to load command file: ${filePath}`, error);
     }
   }
+  registerStoatClassCommands(stoatClass, instance, filePath, baseDir) {
+    const simpleCommands = getSimpleCommands(stoatClass);
+    const category = this.getCategoryFromPath(filePath, baseDir);
+    if (simpleCommands.length === 0) {
+      console.warn(
+        `[Mally] Class ${stoatClass.name} is decorated with @Stoat but has no @SimpleCommand methods. Skipping...`
+      );
+      this.processedStoatClasses.add(stoatClass);
+      return;
+    }
+    for (const cmdDef of simpleCommands) {
+      const method = instance[cmdDef.methodName];
+      if (typeof method !== "function") {
+        console.warn(`[Mally] 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);
+    }
+    this.processedStoatClasses.add(stoatClass);
+  }
   /**
    * Derive category from file path relative to base directory
    */
@@ -383,14 +411,23 @@ var CommandRegistry = class {
     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_reflect_metadata4 = require("reflect-metadata");
 var MallyHandler = 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);
@@ -400,7 +437,11 @@ var MallyHandler = class {
    * Initialize the handler - load all commands
    */
   async init() {
-    await this.registry.loadFromDirectory(this.commandsDir);
+    if (this.commandsDir) {
+      await this.registry.loadFromDirectory(this.commandsDir);
+      return;
+    }
+    await this.registry.autoDiscover(this.discoveryOptions);
   }
   /**
    * Parse a raw message into command context
@@ -537,11 +578,7 @@ var MallyHandler = class {
       return false;
     }
     try {
-      if (methodName) {
-        await instance[methodName](ctx);
-      } else {
-        await instance.run(ctx);
-      }
+      await instance[methodName](ctx);
       if (metadata.cooldown > 0) {
         this.setCooldown(ctx.authorId, metadata);
       }
@@ -580,7 +617,11 @@ var MallyHandler = class {
   async reload() {
     this.registry.clear();
     this.cooldowns.clear();
-    await this.registry.loadFromDirectory(this.commandsDir);
+    if (this.commandsDir) {
+      await this.registry.loadFromDirectory(this.commandsDir);
+      return;
+    }
+    await this.registry.autoDiscover(this.discoveryOptions);
   }
   /**
    * Check if a user is an owner
@@ -643,19 +684,14 @@ var MallyHandler = class {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  BaseCommand,
-  Command,
   CommandRegistry,
   Guard,
   METADATA_KEYS,
   MallyHandler,
   SimpleCommand,
   Stoat,
-  buildCommandMetadata,
   buildSimpleCommandMetadata,
-  getCommandOptions,
   getGuards,
   getSimpleCommands,
-  isCommand,
   isStoatClass
 });