@marshmallow-stoat/mally 0.1.0 → 0.2.0

package/dist/index.mjs

@@ -1,30 +1,84 @@
-// 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
 import "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) {
@@ -49,35 +103,6 @@ function getSimpleCommands(target) {
   return Reflect.getMetadata(METADATA_KEYS.SIMPLE_COMMANDS, target) || [];
 }
 
-// src/decorators/Command.ts
-import "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
 import "reflect-metadata";
 function Guard(guardClass) {
@@ -107,12 +132,14 @@ function buildSimpleCommandMetadata(options, methodName, category) {
 
 // src/registry.ts
 import * as path from "path";
+import * as fs from "fs/promises";
 import { pathToFileURL } from "url";
 import { glob } from "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;
   }
   /**
@@ -137,6 +164,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 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
    */
@@ -147,9 +213,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();
@@ -206,6 +269,7 @@ var CommandRegistry = class {
   clear() {
     this.commands.clear();
     this.aliases.clear();
+    this.processedStoatClasses.clear();
   }
   /**
    * Iterate over commands
@@ -250,77 +314,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 = pathToFileURL(filePath).href;
-      const module = await import(fileUrl);
-      for (const exportKey of Object.keys(module)) {
-        const exported = module[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);
-          }
+      await import(fileUrl);
+      const allStoatClasses = decoratorStore.getStoatClasses();
+      for (const [stoatClass, stoatInstance] of allStoatClasses.entries()) {
+        if (knownStoatClasses.has(stoatClass) || this.processedStoatClasses.has(stoatClass)) {
           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...`
-          );
-          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
    */
@@ -333,6 +366,14 @@ var CommandRegistry = class {
     return void 0;
   }
 };
+_CommandRegistry.DEFAULT_AUTO_DISCOVERY_IGNORES = [
+  "**/node_modules/**",
+  "**/.git/**",
+  "**/*.d.ts",
+  "**/*.test.*",
+  "**/*.spec.*"
+];
+var CommandRegistry = _CommandRegistry;
 
 // src/handler.ts
 import "reflect-metadata";
@@ -341,6 +382,7 @@ var MallyHandler = class {
     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);
@@ -350,7 +392,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
@@ -487,11 +533,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);
       }
@@ -530,7 +572,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
@@ -592,19 +638,14 @@ var MallyHandler = class {
   }
 };
 export {
-  BaseCommand,
-  Command,
   CommandRegistry,
   Guard,
   METADATA_KEYS,
   MallyHandler,
   SimpleCommand,
   Stoat,
-  buildCommandMetadata,
   buildSimpleCommandMetadata,
-  getCommandOptions,
   getGuards,
   getSimpleCommands,
-  isCommand,
   isStoatClass
 };

package/package.json

@@ -1,7 +1,11 @@
 {
   "name": "@marshmallow-stoat/mally",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "A high-performance, decorator-based command handler for the Stoat ecosystem.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Arsabutispik/marshmallow"
+  },
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
@@ -19,12 +23,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "build": "tsup src/index.ts --format cjs,esm --dts",
-    "dev": "tsup src/index.ts --format cjs,esm --watch --dts",
-    "lint": "eslint src/**/*.ts",
-    "format": "prettier --write src/**/*.ts"
-  },
   "dependencies": {
     "reflect-metadata": "^0.2.2",
     "stoat.js": "^7.3.6",
@@ -38,5 +36,11 @@
   },
   "peerDependencies": {
     "reflect-metadata": "^0.2.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts --format cjs,esm --watch --dts",
+    "lint": "eslint src/**/*.ts",
+    "format": "prettier --write src/**/*.ts"
   }
-}
+}