@carzo/enire 3.0.0

package/README.md

@@ -0,0 +1,57 @@
+# enire
+A modern discord.js-based framework for building hybrid Discord bots with a unified command pipeline.
+
+## Install
+```bash
+npm install enire@latest
+```
+
+## Features
+- Unified hybrid pipeline (prefix + slash) for a single execution path
+- Modular command / interaction / event loaders
+- Global and per-command plugins (guards/conditions)
+- Built-in cooldown tracking with buckets
+- Centralized framework error channel (`frameworkError` + `error`)
+- Debug mode hooks (`debug` event)
+- Optional help command
+- Built-in arguments parser
+
+## Example setup
+```js
+const { Enire, GatewayIntentBits, Partials } = require("enire");
+
+const client = new Enire({
+  intents: [
+    GatewayIntentBits.Guilds,
+    GatewayIntentBits.GuildMessages,
+    GatewayIntentBits.MessageContent
+  ],
+  partials: [Partials.Channel],
+  prefix: "!",
+  debug: true
+});
+
+client.load("./files");
+
+client.on("frameworkError", (error, ctx) => {
+  console.error("Framework error:", error, "Context:", ctx?.command?.data?.name ?? null);
+});
+
+client.login("TOKEN");
+```
+
+## Breaking changes in v3
+- Framework is now branded as **enire** (package name changed from `erine` to `enire`).
+- Runtime execution is unified for prefix and slash commands.
+- Core listeners are internally managed by `Enire` with centralized error forwarding.
+- `Erine` is kept as a compatibility alias of `Enire`, but `Enire` is now the canonical class name.
+- Command/Group builders now support `guards` metadata, and commands support builder-level cooldown metadata.
+- Message-update handling is now routed through the shared message pipeline.
+
+## Migration notes
+- Replace imports from `Erine` with `Enire` when possible.
+- If you had custom error handling on process events, prefer listening to `frameworkError`.
+- If you rely on command plugins only, you can now also define command/group guards directly in builders.
+
+## Disclaimer
+enire is not affiliated with Discord or discord.js.

package/lib/classes/Client.d.ts

@@ -0,0 +1,37 @@
+import { Client, ClientOptions, CommandInteraction, Message, Snowflake } from "discord.js";
+import { Context } from "./Context.js";
+import { Loader, Plugin } from "./Loader.js";
+import { HelpCommand } from "./HelpCommand.js";
+import { Cooldowns } from "./Cooldowns.js";
+
+export interface EnireRestrictions {
+  userIDs: Set<Snowflake>;
+  guildIDs: Set<Snowflake>;
+}
+
+export interface EnireOptions extends ClientOptions {
+  autoSync?: boolean;
+  context?: typeof Context;
+  guildOnly?: boolean;
+  owners?: Snowflake[];
+  prefix: string | string[] | ((ctx: Context) => Promise<string> | string);
+  replyOnEdit?: boolean;
+  helpCommand?: typeof HelpCommand;
+  restrictions?: EnireRestrictions;
+  debug?: boolean;
+}
+
+export declare class Enire extends Client {
+  cooldowns: Cooldowns;
+  loader: Loader;
+  ops: EnireOptions;
+  constructor(options: EnireOptions);
+  addGlobalPlugins(plugins: Plugin[]): this;
+  getContext(data: CommandInteraction | Message): Context;
+  load(dir: string, reload?: boolean): Promise<import("./Loader.js").ModuleData<import("./builders/InteractionBuilder.js").InteractionBuilder | import("./builders/CommandBuilder.js").CommandBuilder | import("./builders/EventBuilder.js").EventBuilder | import("./builders/GroupBuilder.js").GroupBuilder, any[]>[]>;
+  sync(guildIDs?: string[]): Promise<void>;
+  handleFrameworkError(error: unknown, ctx?: Context | null): void;
+  login(token: string): Promise<string>;
+}
+
+export { Enire as Erine };

package/lib/classes/Client.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Erine = exports.Enire = void 0;
+
+const discord_js_1 = require("discord.js");
+const Context_js_1 = require("./Context.js");
+const Loader_js_1 = require("./Loader.js");
+const Cooldowns_js_1 = require("./Cooldowns.js");
+const Utils_js_1 = require("./Utils.js");
+
+let processHandlersBound = false;
+
+class Enire extends discord_js_1.Client {
+  cooldowns = new Cooldowns_js_1.Cooldowns(this);
+  loader = new Loader_js_1.Loader({ client: this });
+  ops;
+  #coreListenersBound = false;
+
+  constructor(options) {
+    super(options);
+    this.ops = options;
+
+    if (this.ops.guildOnly === undefined) this.ops.guildOnly = true;
+    if (typeof this.ops.debug !== "boolean") this.ops.debug = false;
+  }
+
+  addGlobalPlugins(plugins) {
+    this.loader.globalPlugins.push(...plugins);
+    return this;
+  }
+
+  getContext(data) {
+    return new (this.ops.context || Context_js_1.Context)(this, data);
+  }
+
+  async load(dir, reload = false) {
+    if (!dir) throw new SyntaxError("Missing module path in Enire#load!");
+    return this.loader.load(dir, reload);
+  }
+
+  async sync(guildIDs) {
+    await this.loader.sync(guildIDs);
+  }
+
+  handleFrameworkError(error, ctx = null) {
+    if (this.ops.debug) {
+      const summary = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+      this.emit("debug", `[enire] ${summary}`);
+    }
+
+    this.emit("frameworkError", error, ctx);
+    this.emit("error", error);
+  }
+
+  #bindCoreListeners() {
+    if (this.#coreListenersBound) return;
+
+    this.on("messageCreate", async (message) => {
+      try {
+        await Utils_js_1.Utils.handleMessage(this, message, false);
+      } catch (error) {
+        this.handleFrameworkError(error, error?.ctx ?? null);
+      }
+    });
+
+    if (this.ops.replyOnEdit) {
+      this.on("messageUpdate", async (_oldMessage, newMessage) => {
+        try {
+          await Utils_js_1.Utils.handleMessage(this, newMessage, true);
+        } catch (error) {
+          this.handleFrameworkError(error, error?.ctx ?? null);
+        }
+      });
+    }
+
+    this.on("interactionCreate", async (interaction) => {
+      try {
+        await Utils_js_1.Utils.handleInteraction(this, interaction);
+      } catch (error) {
+        this.handleFrameworkError(error, error?.ctx ?? null);
+      }
+    });
+
+    this.#coreListenersBound = true;
+  }
+
+  #bindProcessHandlers() {
+    if (processHandlersBound) return;
+
+    process.on("uncaughtException", (error) => this.handleFrameworkError(error));
+    process.on("unhandledRejection", (error) => this.handleFrameworkError(error));
+
+    processHandlersBound = true;
+  }
+
+  #registerHelpCommand() {
+    if (!this.ops.helpCommand) return;
+
+    const help = new this.ops.helpCommand();
+    if (!this.loader.commands.normal) this.loader.commands.normal = new discord_js_1.Collection();
+
+    this.loader.commands.normal.set("help", {
+      data: help.data,
+      params: help.params,
+      plugins: help.plugins,
+      code: help.code.bind(help),
+    });
+  }
+
+  async login(token) {
+    this.#bindProcessHandlers();
+    this.#bindCoreListeners();
+    this.#registerHelpCommand();
+
+    if (this.ops.debug) {
+      this.rest.on("rateLimited", (details) => {
+        this.emit("debug", `[enire] Rate limited: ${JSON.stringify(details)}`);
+      });
+    }
+
+    return super.login(token);
+  }
+}
+exports.Enire = Enire;
+exports.Erine = Enire;

package/lib/classes/Context.d.ts

@@ -0,0 +1,24 @@
+import { Command, Types } from "../classes/Loader.js";
+import * as P from "./builders/ParamsBuilder.js";
+import { Enire } from "./Client.js";
+import * as DJS from "discord.js";
+
+export declare class Context {
+  bot: Enire;
+  args: string[] | null;
+  data: DJS.Message | DJS.CommandInteraction;
+  prefix: string;
+  command: Command<Types.Normal> | null;
+  parent: Command<Types.Group> | null;
+  params: P.BaseParam[] | null;
+  constructor(bot: Enire, data: DJS.Message | DJS.CommandInteraction);
+  get message(): DJS.Message | null;
+  get interaction(): DJS.CommandInteraction | null;
+  get author(): DJS.User;
+  get channel(): DJS.TextBasedChannel | null;
+  get member(): DJS.GuildMember | DJS.APIInteractionGuildMember | null;
+  get guild(): DJS.Guild | null;
+  send(payload: string | DJS.MessagePayload | DJS.MessageCreateOptions | DJS.InteractionReplyOptions | DJS.InteractionEditReplyOptions): Promise<DJS.Message<boolean>>;
+  react(...emojis: string[]): Promise<DJS.MessageReaction | undefined>;
+  get<T>(param: string): T | null;
+}

package/lib/classes/Context.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = void 0;
+
+const tslib_1 = require("tslib");
+const DJS = tslib_1.__importStar(require("discord.js"));
+
+class Context {
+  bot;
+  args;
+  data;
+  prefix = "";
+  command;
+  parent = null;
+  params;
+
+  constructor(bot, data) {
+    this.bot = bot;
+    this.data = data;
+    this.command = null;
+    this.params = this.data instanceof DJS.Message ? [] : [];
+    this.args = this.data instanceof DJS.Message ? [] : null;
+  }
+
+  get message() {
+    return this.data instanceof DJS.Message ? this.data : null;
+  }
+
+  get interaction() {
+    return this.data instanceof DJS.Message ? null : this.data;
+  }
+
+  get author() {
+    return this.data instanceof DJS.Message ? this.data.author : this.data.user;
+  }
+
+  get channel() {
+    return this.data.channel || null;
+  }
+
+  get member() {
+    return this.data.member || null;
+  }
+
+  get guild() {
+    return this.data.guild || null;
+  }
+
+  async send(payload) {
+    if (this.data instanceof DJS.Message) {
+      return this.data.channel.send(payload);
+    }
+
+    if (this.data.replied || this.data.deferred) {
+      return this.data.editReply(payload);
+    }
+
+    return this.data.reply(payload);
+  }
+
+  async react(...emojis) {
+    if (!(this.data instanceof DJS.Message)) return undefined;
+
+    let lastReaction;
+    for (const emoji of emojis) {
+      lastReaction = await this.data.react(emoji);
+    }
+
+    return lastReaction;
+  }
+
+  get(param) {
+    const lowered = param.toLowerCase();
+
+    if (this.params?.length) {
+      return this.params.find((entry) => entry.name.toLowerCase() === lowered)?.value ?? null;
+    }
+
+    if (this.data instanceof DJS.Message) return null;
+
+    const option = this.data.options?.data?.find((entry) => entry.name.toLowerCase() === lowered);
+    if (!option) return null;
+
+    return option.attachment ?? option.member ?? option.channel ?? option.role ?? option.user ?? option.value ?? null;
+  }
+}
+exports.Context = Context;

package/lib/classes/Cooldowns.d.ts

@@ -0,0 +1,22 @@
+import { Erine } from "./Client";
+import { Collection } from "discord.js";
+export declare enum Bucket {
+    Member = "MEMBER",
+    User = "USER",
+    Guild = "GUILD",
+    Channel = "CHANNEL"
+}
+export declare class Cooldowns {
+    bot: Erine;
+    track: Collection<string, number>;
+    constructor(bot: Erine);
+    getCooldownSource(command: string, id: string, bucket: Bucket): Promise<number | undefined>;
+    setCooldownSource(command: string, id: string, bucket: Bucket, time: number): Promise<void>;
+    check(command: string, id: string, cooldown: number, bucket: Bucket): Promise<{
+        command: string;
+        id: string;
+        time: number;
+        bucket: Bucket;
+        left: number;
+    } | null>;
+}

package/lib/classes/Cooldowns.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.Cooldowns=exports.Bucket=void 0;const discord_js_1=require("discord.js");var Bucket;!function(e){e.Member="MEMBER",e.User="USER",e.Guild="GUILD",e.Channel="CHANNEL"}(Bucket||(exports.Bucket=Bucket={}));class Cooldowns{bot;track=new discord_js_1.Collection;constructor(e){this.bot=e}async getCooldownSource(e,o,t){return this.track.get(e+`#${t}#`+o)}async setCooldownSource(e,o,t,s){this.track.set(e+`#${t}#`+o,Date.now()),setTimeout(()=>this.track.delete(e+`#${t}#`+o),s)}async check(e,o,t,s){var c=await this.getCooldownSource(e,o,s);return c&&Date.now()-c<t?{command:e,id:o,time:t,bucket:s,left:t-(Date.now()-c)}:null}}exports.Cooldowns=Cooldowns;

package/lib/classes/Errors.d.ts

@@ -0,0 +1,135 @@
+import { Channel, ChannelType, Guild, PermissionResolvable, User } from "discord.js";
+import { BaseParam, ChannelParam } from "./builders/ParamsBuilder.js";
+import { Context } from "./Context.js";
+declare class GuildOnly extends Error {
+    ctx: Context;
+    constructor(context: Context, message?: string);
+    get user(): User;
+}
+declare class NotOwner extends Error {
+    ctx: Context;
+    constructor(context: Context, message?: string);
+    get user(): User;
+}
+declare class CommandNotFound extends Error {
+    ctx: Context;
+    provided: string;
+    constructor(context: Context, provided: string, message?: string);
+}
+declare class UnknownCommandError extends Error {
+    ctx: Context;
+    error: any;
+    constructor(context: Context, error: any, message?: string);
+}
+declare class MissingRequiredParam extends Error {
+    ctx: Context;
+    param: BaseParam;
+    constructor(context: Context, param: BaseParam, message?: string);
+}
+declare class InvalidParam extends Error {
+    ctx: Context;
+    metadata: Record<string, any>;
+    constructor(context: Context, message?: string, metadata?: Record<string, any>);
+}
+declare class InvalidParamNumber extends Error {
+    ctx: Context;
+    param: BaseParam;
+    constructor(context: Context, param: BaseParam, message?: string);
+}
+declare class InvalidParamBoolean extends Error {
+    ctx: Context;
+    param: BaseParam;
+    constructor(context: Context, param: BaseParam, message?: string);
+}
+declare class InvalidParamChoice extends Error {
+    ctx: Context;
+    param: BaseParam;
+    choices: {
+        name: string;
+        value: any;
+    }[];
+    constructor(context: Context, param: BaseParam, choices: {
+        name: string;
+        value: any;
+    }[], message?: string);
+}
+declare class InvalidParamMember extends Error {
+    ctx: Context;
+    param: BaseParam;
+    constructor(context: Context, param: BaseParam, message?: string);
+}
+declare class InvalidParamChannel extends Error {
+    ctx: Context;
+    param: BaseParam;
+    constructor(context: Context, param: BaseParam, message?: string);
+}
+declare class InvalidParamRole extends Error {
+    ctx: Context;
+    param: BaseParam;
+    constructor(context: Context, param: BaseParam, message?: string);
+}
+declare class InvalidChannelType extends Error {
+    ctx: Context;
+    param: ChannelParam;
+    provided: ChannelType;
+    expected: ChannelType[];
+    constructor(context: Context, param: ChannelParam, provided: ChannelType, expected: ChannelType[], message?: string);
+}
+declare class InvalidParamAttachment extends Error {
+    ctx: Context;
+    param: BaseParam;
+    constructor(context: Context, param: BaseParam, message?: string);
+}
+declare class MissingPermission extends Error {
+    ctx: Context;
+    permissions: PermissionResolvable[];
+    constructor(context: Context, perms: PermissionResolvable[], message?: string);
+}
+declare class MissingChannelPermission extends Error {
+    ctx: Context;
+    permissions: PermissionResolvable[];
+    channel: Channel;
+    constructor(context: Context, perms: PermissionResolvable[], channel: Channel, message?: string);
+}
+declare class MissingBotPermission extends Error {
+    ctx: Context;
+    permissions: PermissionResolvable[];
+    constructor(context: Context, perms: PermissionResolvable[], message?: string);
+}
+declare class MissingBotChannelPermission extends Error {
+    ctx: Context;
+    permissions: PermissionResolvable[];
+    channel: Channel;
+    constructor(context: Context, perms: PermissionResolvable[], channel: Channel, message?: string);
+}
+declare class NotNSFW extends Error {
+    ctx: Context;
+    constructor(context: Context, message?: string);
+}
+declare class NotInChannelType extends Error {
+    ctx: Context;
+    types: ChannelType[];
+    channel: Channel;
+    constructor(ctx: Context, types: ChannelType[], channel: Channel, message?: string);
+}
+declare class OnlyForIDs extends Error {
+    ctx: Context;
+    snowflakes: string[];
+    constructor(context: Context, snowflakes: string[], message?: string);
+}
+declare class CommandInCooldown extends Error {
+    ctx: Context;
+    timeLeft: number;
+    constructor(context: Context, timeLeft: number, message?: string);
+}
+declare class RestrictedUser extends Error {
+    ctx: Context;
+    user: User;
+    constructor(ctx: Context, user: User, message?: string);
+}
+declare class RestrictedGuild extends Error {
+    ctx: Context;
+    guild: Guild;
+    constructor(ctx: Context, guild: Guild, message?: string);
+}
+export { InvalidParam, GuildOnly, NotOwner, CommandNotFound, UnknownCommandError, MissingRequiredParam, InvalidParamNumber, InvalidParamChoice, MissingPermission, MissingChannelPermission, MissingBotPermission, MissingBotChannelPermission, InvalidParamBoolean, InvalidParamMember, InvalidParamChannel, InvalidParamRole, InvalidChannelType, InvalidParamAttachment, NotNSFW, NotInChannelType, OnlyForIDs, CommandInCooldown, RestrictedUser, RestrictedGuild };

package/lib/classes/Errors.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.RestrictedGuild=exports.RestrictedUser=exports.CommandInCooldown=exports.OnlyForIDs=exports.NotInChannelType=exports.NotNSFW=exports.InvalidParamAttachment=exports.InvalidChannelType=exports.InvalidParamRole=exports.InvalidParamChannel=exports.InvalidParamMember=exports.InvalidParamBoolean=exports.MissingBotChannelPermission=exports.MissingBotPermission=exports.MissingChannelPermission=exports.MissingPermission=exports.InvalidParamChoice=exports.InvalidParamNumber=exports.MissingRequiredParam=exports.UnknownCommandError=exports.CommandNotFound=exports.NotOwner=exports.GuildOnly=exports.InvalidParam=void 0;class GuildOnly extends Error{ctx;constructor(s,e="This command is only available in guilds."){super(e),this.ctx=s}get user(){return this.ctx.author}}exports.GuildOnly=GuildOnly;class NotOwner extends Error{ctx;constructor(s,e="Someone that is not register as owner tried to use this command."){super(e),this.ctx=s}get user(){return this.ctx.author}}exports.NotOwner=NotOwner;class CommandNotFound extends Error{ctx;provided;constructor(s,e,r="That command doesn't exist."){super(r),this.ctx=s,this.provided=e}}exports.CommandNotFound=CommandNotFound;class UnknownCommandError extends Error{ctx;error;constructor(s,e,r="An unknown error"){super(r),this.ctx=s,this.error=e}}exports.UnknownCommandError=UnknownCommandError;class MissingRequiredParam extends Error{ctx;param;constructor(s,e,r="You have to provide all required parameters."){super(r),this.ctx=s,this.param=e}}exports.MissingRequiredParam=MissingRequiredParam;class InvalidParam extends Error{ctx;metadata;constructor(s,e="Some parameter is invalid in arguments provided.",r={}){super(e),this.ctx=s,this.metadata=r}}exports.InvalidParam=InvalidParam;class InvalidParamNumber extends Error{ctx;param;constructor(s,e,r="Some parameter in that command isn't a valid number."){super(r),this.ctx=s,this.param=e}}exports.InvalidParamNumber=InvalidParamNumber;class InvalidParamBoolean extends Error{ctx;param;constructor(s,e,r="Some parameter in that command isn't boolean."){super(r),this.ctx=s,this.param=e}}exports.InvalidParamBoolean=InvalidParamBoolean;class InvalidParamChoice extends Error{ctx;param;choices;constructor(s,e,r,t="Some parameter in that command isn't a valid choice."){super(t),this.ctx=s,this.param=e,this.choices=r}}exports.InvalidParamChoice=InvalidParamChoice;class InvalidParamMember extends Error{ctx;param;constructor(s,e,r="Some parameter in that command isn't a valid member."){super(r),this.ctx=s,this.param=e}}exports.InvalidParamMember=InvalidParamMember;class InvalidParamChannel extends Error{ctx;param;constructor(s,e,r="Some parameter in that command isn't a valid channel."){super(r),this.ctx=s,this.param=e}}exports.InvalidParamChannel=InvalidParamChannel;class InvalidParamRole extends Error{ctx;param;constructor(s,e,r="Some parameter in that command isn't a valid role."){super(r),this.ctx=s,this.param=e}}exports.InvalidParamRole=InvalidParamRole;class InvalidChannelType extends Error{ctx;param;provided;expected;constructor(s,e,r,t,n="Some parameter in that command isn't a valid channel type allowed."){super(n),this.ctx=s,this.param=e,this.provided=r,this.expected=t}}exports.InvalidChannelType=InvalidChannelType;class InvalidParamAttachment extends Error{ctx;param;constructor(s,e,r="Some parameter in that command isn't a valid attachment."){super(r),this.ctx=s,this.param=e}}exports.InvalidParamAttachment=InvalidParamAttachment;class MissingPermission extends Error{ctx;permissions;constructor(s,e,r="The command author doesn't have permissions enough to execute this command."){super(r),this.ctx=s,this.permissions=e}}exports.MissingPermission=MissingPermission;class MissingChannelPermission extends Error{ctx;permissions;channel;constructor(s,e,r,t="The command author doesn't have permissions enough in a channel to execute this command."){super(t),this.ctx=s,this.permissions=e,this.channel=r}}exports.MissingChannelPermission=MissingChannelPermission;class MissingBotPermission extends Error{ctx;permissions;constructor(s,e,r="I don't have permissions enough to execute this command."){super(r),this.ctx=s,this.permissions=e}}exports.MissingBotPermission=MissingBotPermission;class MissingBotChannelPermission extends Error{ctx;permissions;channel;constructor(s,e,r,t="I don't have permissions enough in that channel to execute this command."){super(t),this.ctx=s,this.permissions=e,this.channel=r}}exports.MissingBotChannelPermission=MissingBotChannelPermission;class NotNSFW extends Error{ctx;constructor(s,e="This command can only be executed in a NSFW channel."){super(e),this.ctx=s}}exports.NotNSFW=NotNSFW;class NotInChannelType extends Error{ctx;types;channel;constructor(s,e,r,t="This command can only be executed in certain channel types."){super(t),this.ctx=s,this.types=e,this.channel=r}}exports.NotInChannelType=NotInChannelType;class OnlyForIDs extends Error{ctx;snowflakes;constructor(s,e,r="This command can only be used by specified users."){super(r),this.ctx=s,this.snowflakes=e}}exports.OnlyForIDs=OnlyForIDs;class CommandInCooldown extends Error{ctx;timeLeft;constructor(s,e,r="This command is in cooldown."){super(r),this.ctx=s,this.timeLeft=e}}exports.CommandInCooldown=CommandInCooldown;class RestrictedUser extends Error{ctx;user;constructor(s,e,r="Looks like this user is restricted from bot."){super(r),this.ctx=s,this.user=e}}exports.RestrictedUser=RestrictedUser;class RestrictedGuild extends Error{ctx;guild;constructor(s,e,r="Looks like this guild is restricted from bot."){super(r),this.ctx=s,this.guild=e}}exports.RestrictedGuild=RestrictedGuild;

package/lib/classes/HelpCommand.d.ts

@@ -0,0 +1,15 @@
+import { type Plugin, CommandBuilder, Context, CommandHelpingObject, GroupHelpingObject, ParamsBuilder } from "../main.js";
+export declare class HelpCommand {
+    data: CommandBuilder;
+    plugins: Plugin[];
+    params: ParamsBuilder;
+    code(ctx: Context): Promise<void>;
+    sendEmpty(ctx: Context): Promise<void>;
+    sendNotFound(ctx: Context): Promise<void>;
+    sendCommand(ctx: Context, command: CommandHelpingObject): Promise<void>;
+    sendGroup(ctx: Context, group: GroupHelpingObject): Promise<void>;
+    getCommand(ctx: Context, q: string): CommandHelpingObject | null;
+    getGroup(ctx: Context, q: string): GroupHelpingObject | null;
+    private doEmbed;
+    private c;
+}

package/lib/classes/HelpCommand.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.HelpCommand=void 0;const main_js_1=require("../main.js");class HelpCommand{data=new main_js_1.CommandBuilder({name:"help",aliases:["h"],description:"Shows this command"});plugins=[];params=(new main_js_1.ParamsBuilder).addString({name:"query",description:"An optional command/group/subcommand name",required:!1,ellipsis:!0});async code(a){var e;return a.get("query")?(e=this.getCommand(a,a.get("query")))?this.sendCommand(a,e):(e=this.getGroup(a,a.get("query")))?this.sendGroup(a,e):this.sendNotFound(a):this.sendEmpty(a)}async sendEmpty(a){await a.send({embeds:[this.doEmbed(a).setDescription("Welcome to my help")]})}async sendNotFound(a){await a.send("I was unable to find something related to that!")}async sendCommand(a,e){var t=e.data.aliases.length?`[${[e.data.name].concat(e.data.aliases).join("|")}]`:e.data.name,n=e.group?e.group.data.aliases?.length?`[${[e.group.data.name].concat(e.group.data.aliases).join("|")}] `:e.group.data.name+" ":"",s=e.params?.params.length?e.params.params.map(a=>`**${a.name}**${a.required?"*":"?"} :: `+a.description).join("\n"):null,d=e.params?.params.length?e.params.params.map(a=>""+a.name+(a.required?"*":"?")).join(" "):"";await a.send({embeds:[this.doEmbed(a).setTitle(e.data.name).setDescription(e.data.description).addFields({name:"Usage",value:a.prefix+n+t+" "+d}).addFields({name:"Arguments",value:s||"Without arguments."})]})}async sendGroup(a,e){var t=e.data.aliases?.length?`[${[e.data.name].concat(e.data.aliases).join("|")}] `:e.data.name,n=e.subcommands.map(a=>`\`${e.data.name} ${a.data.name}\` :: `+a.data.description);await a.send({embeds:[this.doEmbed(a).setTitle(t).setDescription(e.data.description).addFields({name:"Subcommands",value:n.length?n.join("\n"):"Without sub commands."})]})}getCommand(a,e){let t=a.bot.loader.walkCommands();return e=this.c(e),(a=t.find(a=>!a.group&&this.c(a.data.name)==e||a.data.aliases.map(this.c).includes(e)))||(t=t.filter(a=>a.group).map(a=>({...a,regexp:new RegExp(`^(${(a.group.data.aliases||[]).concat(a.group.data.name).join("|")})( +)(${(a.data.aliases||[]).concat(a.data.name).join("|")})$`,"gi"),full:a.group.data.name+" "+a.data.name}))).find(a=>a.regexp.test(e))||null}getGroup(a,e){e=this.c(e);let t=a.bot.loader.walkCommands().filter(a=>a.group).map(a=>a.group).find(a=>this.c(a.data.name)==e||a.data.aliases?.map(this.c).includes(e));return t?(a=a.bot.loader.walkCommands().filter(a=>a.group&&a.group.data.name==t.data.name).map(a=>({...a,regexp:new RegExp(`^(${(a.group.data.aliases||[]).concat(a.group.data.name).join("|")})( +)(${(a.data.aliases||[]).concat(a.data.name).join("|")})$`,"gi"),full:a.group.data.name+" "+a.data.name})),{...t,subcommands:a}):null}doEmbed(a){return(new main_js_1.EmbedBuilder).setAuthor({name:a.author.username,iconURL:a.author.displayAvatarURL()}).setTimestamp().setColor("Blurple").setFooter({text:a.bot.user?.username+"'s Help",iconURL:a.bot.user.displayAvatarURL()})}c(a){return a.toLowerCase().trim()}}exports.HelpCommand=HelpCommand;

package/lib/classes/Loader.d.ts

@@ -0,0 +1,85 @@
+import { InteractionBuilder } from "./builders/InteractionBuilder.js";
+import { Collection, REST } from "discord.js";
+import { CommandBuilder } from "./builders/CommandBuilder.js";
+import { ParamsBuilder } from "./builders/ParamsBuilder.js";
+import { EventBuilder } from "./builders/EventBuilder.js";
+import { GroupBuilder } from "./builders/GroupBuilder.js";
+import { Plugins as EnirePlugins } from "../main.js";
+import { Context } from "./Context.js";
+import { Enire } from "./Client.js";
+
+export interface ModuleData<T extends unknown = unknown, K extends any[] = any[]> {
+  data: CommandBuilder | GroupBuilder | InteractionBuilder | EventBuilder;
+  plugins?: T extends CommandBuilder ? (typeof EnirePlugins[] | Plugin[]) : never;
+  params?: T extends CommandBuilder ? ParamsBuilder : never;
+  code?: T extends CommandBuilder
+    ? (ctx: Context) => Promise<void>
+    : T extends InteractionBuilder
+    ? (interaction: any) => Promise<void>
+    : T extends EventBuilder
+    ? (bot: Enire, ...args: K) => Promise<void>
+    : undefined;
+}
+
+export type AsyncFunction<S, T> = (args: S) => Promise<T>;
+export type SyncFunction<S, T> = (args: S) => T;
+export type Plugin = AsyncFunction<Context, boolean> | SyncFunction<Context, boolean> | Promise<(ctx: Context) => Promise<boolean>>;
+
+export interface CommandStructures {
+  normal: {
+    data: CommandBuilder;
+    params?: ParamsBuilder;
+    plugins?: Plugin[];
+    code: (ctx: Context) => Promise<void>;
+  };
+  group: {
+    data: GroupBuilder;
+  };
+}
+
+export declare enum Types {
+  Normal = "normal",
+  Group = "group"
+}
+
+export type Command<K extends keyof CommandStructures = "normal"> = CommandStructures[K];
+
+interface EnireCollected {
+  normal: Collection<string, Command<"normal">> | null;
+  group: Collection<string, Command<"group">> | null;
+}
+
+interface LoaderOptions {
+  client: Enire;
+}
+
+export interface CommandHelpingObject extends Command<Types.Normal> {
+  group: Command<Types.Group> | null;
+}
+
+type ErineInteractionTypes =
+  | "autocomplete"
+  | "button"
+  | "chatInput"
+  | "messageContextMenu"
+  | "modalSubmit"
+  | "userContextMenu"
+  | "channelSelectMenu"
+  | "roleSelectMenu"
+  | "stringSelectMenu"
+  | "userSelectMenu"
+  | "mentionableSelectMenu"
+  | "anyInteraction";
+
+export declare class Loader {
+  client: Enire;
+  commands: EnireCollected;
+  interactions: Record<ErineInteractionTypes, Collection<string, ModuleData<InteractionBuilder>>>;
+  globalPlugins: Plugin[];
+  listeners: Collection<string, ModuleData<InteractionBuilder>> | null;
+  rest: REST;
+  constructor(options: LoaderOptions);
+  load(dir: string, reload?: boolean): Promise<ModuleData<InteractionBuilder | CommandBuilder | EventBuilder | GroupBuilder, any[]>[]>;
+  walkCommands(callable?: (command: Command<Types>) => number): CommandHelpingObject[];
+  sync(guildIDs?: string[]): Promise<void>;
+}