reciple 1.6.0 → 1.7.0

package/README.md

@@ -6,8 +6,10 @@
     <a href="https://www.codefactor.io/repository/github/falloutstudios/reciple/overview/main"><img src="https://www.codefactor.io/repository/github/falloutstudios/reciple/badge/main" alt="CodeFactor"></a>
 </h1>
 
-A simple modular Discord bot made with Discord.js written in TypeScript.
+A simple Dicord.js command handler that just works.
 
+# Join Discord
+[![Discord Invite](https://i.imgur.com/GffJByO.png)](https://discord.gg/2CattJYNpw)
 
 ## Installation
 To install the bot, run the following command:

package/bin/bin.js

@@ -11,7 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 var _a, _b;
 Object.defineProperty(exports, "__esModule", { value: true });
-const Config_1 = require("./reciple/classes/Config");
+const RecipleConfig_1 = require("./reciple/classes/RecipleConfig");
 const RecipleClient_1 = require("./reciple/classes/RecipleClient");
 const fs_1 = require("fs");
 const version_1 = require("./reciple/version");
@@ -28,13 +28,16 @@ if ((0, fs_1.readdirSync)('./').filter(f => !f.startsWith('.') && allowedFiles.i
     if (ask.toString().toLowerCase() !== 'y')
         process.exit(0);
 }
-const config = new Config_1.RecipleConfig((_b = flags_1.flags.config) !== null && _b !== void 0 ? _b : './reciple.yml').parseConfig().getConfig();
+const config = new RecipleConfig_1.RecipleConfig((_b = flags_1.flags.config) !== null && _b !== void 0 ? _b : './reciple.yml').parseConfig().getConfig();
 const client = new RecipleClient_1.RecipleClient(Object.assign({ config: config }, config.client));
+if (config.fileLogging.clientLogs)
+    client.logger.info('Reciple Client v' + version_1.version + ' is starting...');
 (() => __awaiter(void 0, void 0, void 0, function* () {
     yield client.startModules();
     client.on('ready', () => __awaiter(void 0, void 0, void 0, function* () {
         var _c;
-        client.logger.warn(`Logged in as ${((_c = client.user) === null || _c === void 0 ? void 0 : _c.tag) || 'Unknown'}!`);
+        if (client.isClientLogsEnabled())
+            client.logger.warn(`Logged in as ${((_c = client.user) === null || _c === void 0 ? void 0 : _c.tag) || 'Unknown'}!`);
         yield client.loadModules();
         client.addCommandListeners();
     }));

package/bin/index.d.ts

@@ -1,7 +1,7 @@
 import discord from 'discord.js';
 export declare const discordjs: typeof discord;
 export * from './reciple/classes/RecipleClient';
-export * from './reciple/classes/Config';
+export * from './reciple/classes/RecipleConfig';
 export * from './reciple/classes/builders/InteractionCommandBuilder';
 export * from './reciple/classes/builders/MessageCommandBuilder';
 export * from './reciple/classes/builders/MessageCommandOptionBuilder';

package/bin/index.js

@@ -21,7 +21,7 @@ exports.discordjs = void 0;
 const discord_js_1 = __importDefault(require("discord.js"));
 exports.discordjs = discord_js_1.default;
 __exportStar(require("./reciple/classes/RecipleClient"), exports);
-__exportStar(require("./reciple/classes/Config"), exports);
+__exportStar(require("./reciple/classes/RecipleConfig"), exports);
 __exportStar(require("./reciple/classes/builders/InteractionCommandBuilder"), exports);
 __exportStar(require("./reciple/classes/builders/MessageCommandBuilder"), exports);
 __exportStar(require("./reciple/classes/builders/MessageCommandOptionBuilder"), exports);

package/bin/reciple/classes/RecipleClient.d.ts

@@ -2,11 +2,11 @@ import { InteractionCommandBuilder, RecipleInteractionCommandExecute } from './b
 import { interactionCommandBuilders } from '../registerInteractionCommands';
 import { MessageCommandBuilder, RecipleMessageCommandExecute } from './builders/MessageCommandBuilder';
 import { Logger as ILogger } from 'fallout-utility';
-import { Config } from './Config';
+import { Config } from './RecipleConfig';
 import { ApplicationCommandDataResolvable, Awaitable, Client, ClientEvents, ClientOptions, CommandInteraction, Interaction, Message } from 'discord.js';
 import { recipleCommandBuilders, RecipleModule, RecipleScript } from '../modules';
 export interface RecipleClientOptions extends ClientOptions {
-    config: Config;
+    config?: Config;
 }
 export interface RecipleClientCommands {
     MESSAGE_COMMANDS: {
@@ -19,6 +19,7 @@ export interface RecipleClientCommands {
 export interface RecipleClientEvents extends ClientEvents {
     recipleMessageCommandCreate: [command: RecipleMessageCommandExecute];
     recipleInteractionCommandCreate: [command: RecipleInteractionCommandExecute];
+    recipleReplyError: [error: any];
 }
 export interface RecipleClient<Ready extends boolean = boolean> extends Client<Ready> {
     on<E extends keyof RecipleClientEvents>(event: E, listener: (...args: RecipleClientEvents[E]) => Awaitable<void>): this;
@@ -41,13 +42,45 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
     logger: ILogger;
     version: string;
     constructor(options: RecipleClientOptions);
-    startModules(): Promise<RecipleClient<Ready>>;
+    /**
+     * Load modules
+     */
+    startModules(folder?: string): Promise<RecipleClient<Ready>>;
+    /**
+     * Execute `onLoad()` from client modules and register interaction commands if enabled
+     */
     loadModules(): Promise<RecipleClient<Ready>>;
-    addModule(script: RecipleScript, registerCommands?: boolean): Promise<void>;
+    /**
+     * Add module
+     */
+    addModule(script: RecipleScript, registerCommands?: boolean, info?: RecipleModule['info']): Promise<void>;
+    /**
+     * Add interaction or message command to client
+     */
     addCommand(command: recipleCommandBuilders): RecipleClient<Ready>;
+    /**
+     * Listed to command executions
+     */
     addCommandListeners(): RecipleClient<Ready>;
+    /**
+     * Execute a Message command
+     */
     messageCommandExecute(message: Message, prefix?: string): Promise<void | RecipleMessageCommandExecute>;
+    /**
+     * Execute an Interaction command
+     */
     interactionCommandExecute(interaction: Interaction | CommandInteraction): Promise<void | RecipleInteractionCommandExecute>;
+    /**
+     * Get a message from config
+     */
     getMessage<T = unknown>(messageKey: string, defaultMessage?: T): T;
+    /**
+     * Returns true if client logs is enabled
+     */
+    isClientLogsEnabled(): boolean;
+    private replpyError;
+    /**
+     * Error message when a command fails to execute
+     */
     private _commandExecuteError;
 }

package/bin/reciple/classes/RecipleClient.js

@@ -22,66 +22,89 @@ const isIgnoredChannel_1 = require("../isIgnoredChannel");
 const hasPermissions_1 = require("../hasPermissions");
 const version_1 = require("../version");
 const logger_1 = require("../logger");
+const RecipleConfig_1 = require("./RecipleConfig");
 const discord_js_1 = require("discord.js");
 const modules_1 = require("../modules");
 const MessageCommandOptions_1 = require("./builders/MessageCommandOptions");
 class RecipleClient extends discord_js_1.Client {
     constructor(options) {
+        var _a, _b, _c;
         super(options);
+        this.config = RecipleConfig_1.RecipleConfig.getDefaultConfig();
         this.commands = { MESSAGE_COMMANDS: {}, INTERACTION_COMMANDS: {} };
         this.otherApplicationCommandData = [];
         this.modules = [];
         this.version = version_1.version;
-        this.logger = (0, logger_1.logger)(!!options.config.fileLogging.stringifyLoggedJSON, !!options.config.fileLogging.debugmode);
+        this.logger = (0, logger_1.logger)(!!((_a = options.config) === null || _a === void 0 ? void 0 : _a.fileLogging.stringifyLoggedJSON), !!((_b = options.config) === null || _b === void 0 ? void 0 : _b.fileLogging.debugmode));
         if (!options.config)
             throw new Error('Config is not defined.');
-        this.config = options.config;
+        this.config = Object.assign(Object.assign({}, this.config), ((_c = options.config) !== null && _c !== void 0 ? _c : {}));
         if (this.config.fileLogging.enabled)
             this.logger.logFile(this.config.fileLogging.logFilePath, false);
-        this.logger.info('Reciple Client v' + version_1.version + ' is starting...');
     }
-    startModules() {
+    /**
+     * Load modules
+     */
+    startModules(folder) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logger.info('Loading modules...');
-            const modules = yield (0, modules_1.loadModules)(this);
+            if (this.isClientLogsEnabled())
+                this.logger.info(`Loading Modules from ${folder !== null && folder !== void 0 ? folder : this.config.modulesFolder}`);
+            const modules = yield (0, modules_1.loadModules)(this, folder);
             if (!modules)
                 throw new Error('Failed to load modules.');
             this.modules = modules.modules;
             return this;
         });
     }
+    /**
+     * Execute `onLoad()` from client modules and register interaction commands if enabled
+     */
     loadModules() {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            for (const module_ of this.modules.map(m => m.script)) {
-                if (typeof (module_ === null || module_ === void 0 ? void 0 : module_.onLoad) === 'function')
-                    yield Promise.resolve(module_.onLoad(this));
+            for (let m in this.modules) {
+                const module_ = this.modules[m];
+                if (typeof ((_a = module_.script) === null || _a === void 0 ? void 0 : _a.onLoad) === 'function') {
+                    yield Promise.resolve(module_.script.onLoad(this)).catch(err => {
+                        var _a;
+                        if (this.isClientLogsEnabled()) {
+                            this.logger.error(`Error loading ${(_a = module_.info.filename) !== null && _a !== void 0 ? _a : 'unknown module'}:`);
+                            this.logger.error(err);
+                        }
+                        this.modules = this.modules.filter((r, i) => i.toString() !== m.toString());
+                    });
+                }
+                if (typeof ((_b = module_.script) === null || _b === void 0 ? void 0 : _b.commands) !== 'undefined') {
+                    for (const command of module_.script.commands) {
+                        this.addCommand(command);
+                    }
+                }
             }
-            this.logger.info(`${this.modules.length} modules loaded.`);
-            for (const command of this.modules.map(m => { var _a; return (_a = m.script.commands) !== null && _a !== void 0 ? _a : []; })[0]) {
-                this.addCommand(command);
+            if (this.isClientLogsEnabled()) {
+                this.logger.info(`${this.modules.length} modules loaded.`);
+                this.logger.info(`${Object.keys(this.commands.MESSAGE_COMMANDS).length} message commands loaded.`);
+                this.logger.info(`${Object.keys(this.commands.INTERACTION_COMMANDS).length} interaction commands loaded.`);
             }
-            this.logger.info(`${Object.keys(this.commands.MESSAGE_COMMANDS).length} message commands loaded.`);
-            this.logger.info(`${Object.keys(this.commands.INTERACTION_COMMANDS).length} interaction commands loaded.`);
             if (!this.config.commands.interactionCommand.registerCommands)
                 return this;
             yield (0, registerInteractionCommands_1.registerInteractionCommands)(this, [...Object.values(this.commands.INTERACTION_COMMANDS), ...this.otherApplicationCommandData]);
             return this;
         });
     }
-    addModule(script, registerCommands = true) {
+    /**
+     * Add module
+     */
+    addModule(script, registerCommands = true, info) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             this.modules.push({
                 script,
-                info: {
-                    filename: undefined,
-                    versions: typeof script.versions == 'string' ? [script.versions] : script.versions,
-                    path: undefined
-                }
+                info: Object.assign({ filename: undefined, versions: typeof script.versions == 'string' ? [script.versions] : script.versions, path: undefined }, info)
             });
             if (typeof (script === null || script === void 0 ? void 0 : script.onLoad) === 'function')
                 yield Promise.resolve(script.onLoad(this));
-            this.logger.info(`${this.modules.length} modules loaded.`);
+            if (this.isClientLogsEnabled())
+                this.logger.info(`${this.modules.length} modules loaded.`);
             for (const command of (_a = script.commands) !== null && _a !== void 0 ? _a : []) {
                 if (!command.name)
                     continue;
@@ -92,6 +115,9 @@ class RecipleClient extends discord_js_1.Client {
             yield (0, registerInteractionCommands_1.registerInteractionCommands)(this, [...Object.values(this.commands.INTERACTION_COMMANDS), ...this.otherApplicationCommandData]);
         });
     }
+    /**
+     * Add interaction or message command to client
+     */
     addCommand(command) {
         var _a;
         if (command.builder === 'MESSAGE_COMMAND') {
@@ -100,11 +126,14 @@ class RecipleClient extends discord_js_1.Client {
         else if (command.builder === 'INTERACTION_COMMAND') {
             this.commands.INTERACTION_COMMANDS[command.name] = command;
         }
-        else {
+        else if (this.isClientLogsEnabled()) {
             this.logger.error(`Unknow command "${(_a = typeof command) !== null && _a !== void 0 ? _a : 'unknown'}".`);
         }
         return this;
     }
+    /**
+     * Listed to command executions
+     */
     addCommandListeners() {
         if (this.config.commands.messageCommand.enabled)
             this.on('messageCreate', (message) => { this.messageCommandExecute(message); });
@@ -112,18 +141,23 @@ class RecipleClient extends discord_js_1.Client {
             this.on('interactionCreate', (interaction) => { this.interactionCommandExecute(interaction); });
         return this;
     }
+    /**
+     * Execute a Message command
+     */
     messageCommandExecute(message, prefix) {
-        var _a;
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             if (!message.content || !this.isReady())
                 return;
             const parseCommand = (0, fallout_utility_1.getCommand)(message.content, prefix || this.config.prefix || '!', this.config.commands.messageCommand.commandArgumentSeparator || ' ');
-            if (!(parseCommand === null || parseCommand === void 0 ? void 0 : parseCommand.command) || !parseCommand)
+            if (!parseCommand || !(parseCommand === null || parseCommand === void 0 ? void 0 : parseCommand.command))
                 return;
-            const command = this.commands.MESSAGE_COMMANDS[parseCommand.command.toLowerCase()];
+            const command = (_a = this.commands.MESSAGE_COMMANDS[parseCommand.command.toLowerCase()]) !== null && _a !== void 0 ? _a : (this.config.commands.messageCommand.allowCommandAlias
+                ? Object.values(this.commands.MESSAGE_COMMANDS).find(c => c.aliases.some(a => { var _a; return a == ((_a = parseCommand.command) === null || _a === void 0 ? void 0 : _a.toLowerCase()); }))
+                : undefined);
             if (!command)
                 return;
-            if ((0, hasPermissions_1.hasPermissions)(command.name, (_a = message.member) === null || _a === void 0 ? void 0 : _a.permissions, this.config.permissions.messageCommands, command)) {
+            if ((0, hasPermissions_1.hasPermissions)(command.name, (_b = message.member) === null || _b === void 0 ? void 0 : _b.permissions, this.config.permissions.messageCommands, command)) {
                 if (!command.allowExecuteInDM && message.channel.type === 'DM'
                     || !command.allowExecuteByBots
                         && (message.author.bot || message.author.system)
@@ -132,11 +166,11 @@ class RecipleClient extends discord_js_1.Client {
                 const commandOptions = command.getCommandOptionValues(parseCommand);
                 if (command.validateOptions) {
                     if (commandOptions.some(o => o.invalid)) {
-                        yield message.reply(this.getMessage('invalidArguments', 'Invalid argument(s) given.')).catch(err => this.logger.debug(err));
+                        yield message.reply(this.getMessage('invalidArguments', 'Invalid argument(s) given.')).catch(er => this.replpyError(er));
                         return;
                     }
                     if (commandOptions.some(o => o.missing)) {
-                        yield message.reply(this.getMessage('notEnoughArguments', 'Not enough arguments.')).catch(err => this.logger.debug(err));
+                        yield message.reply(this.getMessage('notEnoughArguments', 'Not enough arguments.')).catch(er => this.replpyError(er));
                         return;
                     }
                 }
@@ -152,10 +186,13 @@ class RecipleClient extends discord_js_1.Client {
                 return options;
             }
             else {
-                yield message.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch(err => this.logger.debug(err));
+                yield message.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this.replpyError(er));
             }
         });
     }
+    /**
+     * Execute an Interaction command
+     */
     interactionCommandExecute(interaction) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
@@ -165,10 +202,7 @@ class RecipleClient extends discord_js_1.Client {
             if (!command)
                 return;
             if ((0, hasPermissions_1.hasPermissions)(command.name, (_a = interaction.memberPermissions) !== null && _a !== void 0 ? _a : undefined, this.config.permissions.interactionCommands, command)) {
-                // TODO: Deprecated allowEcuteInDM
-                if (!command.allowExecuteInDM && !interaction.inCachedGuild() || (0, isIgnoredChannel_1.isIgnoredChannel)(interaction.channelId, this.config.ignoredChannels))
-                    return;
-                if (!command)
+                if (!command || (0, isIgnoredChannel_1.isIgnoredChannel)(interaction.channelId, this.config.ignoredChannels))
                     return;
                 const options = {
                     interaction: interaction,
@@ -181,29 +215,46 @@ class RecipleClient extends discord_js_1.Client {
                 return options;
             }
             else {
-                yield interaction.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch(err => this.logger.debug(err));
+                yield interaction.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this.replpyError(er));
             }
         });
     }
+    /**
+     * Get a message from config
+     */
     getMessage(messageKey, defaultMessage) {
         var _a, _b;
         return (_b = (_a = this.config.messages[messageKey]) !== null && _a !== void 0 ? _a : defaultMessage) !== null && _b !== void 0 ? _b : messageKey;
     }
+    /**
+     * Returns true if client logs is enabled
+     */
+    isClientLogsEnabled() {
+        return !!this.config.fileLogging.clientLogs;
+    }
+    replpyError(error) {
+        this.emit('recipleReplyError', error);
+    }
+    /**
+     * Error message when a command fails to execute
+     */
     _commandExecuteError(err, command) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logger.error(`An error occured executing ${command.builder.builder == 'MESSAGE_COMMAND' ? 'message' : 'interaction'} command "${command.builder.name}"`);
-            this.logger.error(err);
+            if (this.isClientLogsEnabled()) {
+                this.logger.error(`An error occured executing ${command.builder.builder == 'MESSAGE_COMMAND' ? 'message' : 'interaction'} command "${command.builder.name}"`);
+                this.logger.error(err);
+            }
             if (!err || !command)
                 return;
             if (command === null || command === void 0 ? void 0 : command.message) {
                 if (!this.config.commands.messageCommand.replyOnError)
                     return;
-                yield command.message.reply(this.getMessage('error', 'An error occurred.')).catch(err => this.logger.debug(err));
+                yield command.message.reply(this.getMessage('error', 'An error occurred.')).catch(er => this.replpyError(er));
             }
             else if (command === null || command === void 0 ? void 0 : command.interaction) {
                 if (!this.config.commands.interactionCommand.replyOnError)
                     return;
-                yield command.interaction.followUp(this.getMessage('error', 'An error occurred.')).catch(err => this.logger.debug(err));
+                yield command.interaction.followUp(this.getMessage('error', 'An error occurred.')).catch(er => this.replpyError(er));
             }
         });
     }

package/bin/reciple/classes/{Config.d.ts → RecipleConfig.d.ts}

@@ -10,6 +10,7 @@ export interface Config {
         messageCommand: {
             enabled: boolean;
             replyOnError: boolean;
+            allowCommandAlias: boolean;
             commandArgumentSeparator: string;
         };
         interactionCommand: {
@@ -38,6 +39,7 @@ export interface Config {
     fileLogging: {
         enabled: boolean;
         debugmode: boolean;
+        clientLogs: boolean;
         stringifyLoggedJSON: boolean;
         logFilePath: string;
     };
@@ -52,10 +54,30 @@ export interface Config {
 export declare class RecipleConfig {
     config?: Config;
     configPath: string;
+    static defaultConfigPath: string;
     constructor(configPath: string);
+    /**
+     * Parse the config file
+     */
     parseConfig(): RecipleConfig;
+    /**
+     * Returns the parsed config file
+     */
     getConfig(): Config;
+    /**
+     * Parse token from config
+     */
     parseToken(askIfNull?: boolean): string | null;
+    /**
+     * Check if the config version is supported
+     */
     private isSupportedConfig;
+    /**
+     * Ask for a token
+     */
     private askToken;
+    /**
+     * Get default config
+     */
+    static getDefaultConfig(): Config;
 }

package/bin/reciple/classes/{Config.js → RecipleConfig.js}

@@ -17,10 +17,13 @@ class RecipleConfig {
             throw new Error('Config path is not defined');
         this.configPath = configPath;
     }
+    /**
+     * Parse the config file
+     */
     parseConfig() {
         var _a;
         if (!(0, fs_1.existsSync)(this.configPath)) {
-            const defaultConfigPath = path_1.default.join(__dirname, '../../../resource/reciple.yml');
+            const defaultConfigPath = RecipleConfig.defaultConfigPath;
             if (!(0, fs_1.existsSync)(defaultConfigPath))
                 throw new Error('Default Config file not found. Please reinstall Reciple.');
             const defaultConfig = (0, fallout_utility_1.replaceAll)((0, fs_1.readFileSync)(defaultConfigPath, 'utf-8'), 'VERSION', version_1.version);
@@ -42,12 +45,18 @@ class RecipleConfig {
             throw new Error('Unsupported config version. Your config version: ' + (((_a = this.config) === null || _a === void 0 ? void 0 : _a.version) || 'No version specified.') + ', Reciple version: ' + version_1.version);
         return this;
     }
+    /**
+     * Returns the parsed config file
+     */
     getConfig() {
         if (!this.config)
             throw new Error('Config is not parsed.');
         this.config.token = this.parseToken() || 'TOKEN';
         return this.config;
     }
+    /**
+     * Parse token from config
+     */
     parseToken(askIfNull = true) {
         var _a, _b;
         let token = flags_1.token || null;
@@ -64,12 +73,27 @@ class RecipleConfig {
         }
         return token || (askIfNull ? this.askToken() : null);
     }
+    /**
+     * Check if the config version is supported
+     */
     isSupportedConfig() {
         var _a;
         return (0, version_1.isSupportedVersion)(((_a = this.config) === null || _a === void 0 ? void 0 : _a.version) || '0.0.0', version_1.version);
     }
+    /**
+     * Ask for a token
+     */
     askToken() {
         return flags_1.token || (0, fallout_utility_1.input)({ 'text': 'Bot Token >>> ', echo: '*', repeatIfEmpty: true, exitStrings: ['exit', 'quit', ''], sigint: true }) || null;
     }
+    /**
+     * Get default config
+     */
+    static getDefaultConfig() {
+        if (!(0, fs_1.existsSync)(this.defaultConfigPath))
+            throw new Error("Default config file does not exists.");
+        return yaml_1.default.parse((0, fs_1.readFileSync)(this.defaultConfigPath, 'utf-8'));
+    }
 }
 exports.RecipleConfig = RecipleConfig;
+RecipleConfig.defaultConfigPath = path_1.default.join(__dirname, '../../../resource/reciple.yml');

package/bin/reciple/classes/builders/InteractionCommandBuilder.d.ts

@@ -12,11 +12,12 @@ export declare class InteractionCommandBuilder extends SlashCommandBuilder {
     requiredPermissions: (PermissionFlags | PermissionString)[];
     allowExecuteInDM: boolean;
     execute: (options: RecipleInteractionCommandExecute) => void;
+    /**
+     * Set required permissions before executing the command
+     */
     setRequiredPermissions(requiredPermissions: (keyof PermissionFlags)[]): InteractionCommandBuilder;
     /**
-     * TODO: Deprecated this
-     * @deprecated use `InteractionCommandBuilder.setDMPermission()` instead
+     * Function when the command is executed
      */
-    setAllowExecuteInDM(allowExecuteInDM: boolean): InteractionCommandBuilder;
     setExecute(execute: (options: RecipleInteractionCommandExecute) => void): InteractionCommandBuilder;
 }

package/bin/reciple/classes/builders/InteractionCommandBuilder.js

@@ -10,6 +10,9 @@ class InteractionCommandBuilder extends builders_1.SlashCommandBuilder {
         this.allowExecuteInDM = true;
         this.execute = () => { };
     }
+    /**
+     * Set required permissions before executing the command
+     */
     setRequiredPermissions(requiredPermissions) {
         if (!requiredPermissions || !Array.isArray(requiredPermissions))
             throw new Error('requiredPermissions must be an array.');
@@ -17,15 +20,8 @@ class InteractionCommandBuilder extends builders_1.SlashCommandBuilder {
         return this;
     }
     /**
-     * TODO: Deprecated this
-     * @deprecated use `InteractionCommandBuilder.setDMPermission()` instead
+     * Function when the command is executed
      */
-    setAllowExecuteInDM(allowExecuteInDM) {
-        if (typeof allowExecuteInDM !== 'boolean')
-            throw new Error('allowExecuteInDM must be a boolean.');
-        this.allowExecuteInDM = allowExecuteInDM;
-        return this;
-    }
     setExecute(execute) {
         if (!execute || typeof execute !== 'function')
             throw new Error('execute must be a function.');

package/bin/reciple/classes/builders/MessageCommandBuilder.d.ts

@@ -1,9 +1,8 @@
 import { MessageCommandOptionBuilder } from './MessageCommandOptionBuilder';
 import { Message, PermissionFlags, PermissionString } from 'discord.js';
-import { Command } from 'fallout-utility';
+import { Command as CommandMessage } from 'fallout-utility';
 import { RecipleClient } from '../RecipleClient';
 import { MessageCommandOptions } from './MessageCommandOptions';
-export declare type CommandMessage = Command;
 export interface RecipleMessageCommandExecute {
     message: Message;
     options: MessageCommandOptions;
@@ -22,19 +21,51 @@ export declare class MessageCommandBuilder {
     readonly builder = "MESSAGE_COMMAND";
     name: string;
     description: string;
+    aliases: string[];
     options: MessageCommandOptionBuilder[];
     validateOptions: boolean;
     requiredPermissions: (PermissionFlags | PermissionString)[];
     allowExecuteInDM: boolean;
     allowExecuteByBots: boolean;
     execute: (options: RecipleMessageCommandExecute) => void;
+    /**
+     * Sets the command name
+     */
     setName(name: string): MessageCommandBuilder;
+    /**
+     * Sets the command description
+     */
+    setDescription(description: string): MessageCommandBuilder;
+    /**
+     * Add aliases to the command
+     */
+    addAliases(...aliases: string[]): MessageCommandBuilder;
+    /**
+     * Sets the default required permissions to execute this command
+     */
     setRequiredPermissions(permissions: (PermissionFlags | PermissionString)[]): MessageCommandBuilder;
+    /**
+     * Set if command can be executed in dms
+     */
     setAllowExecuteInDM(allowExecuteInDM: boolean): MessageCommandBuilder;
+    /**
+     * Allow command to be executed by bots
+     */
     setAllowExecuteByBots(allowExecuteByBots: boolean): MessageCommandBuilder;
-    setDescription(description: string): MessageCommandBuilder;
+    /**
+     * Function when the command is executed
+     */
     setExecute(execute: (options: RecipleMessageCommandExecute) => void): MessageCommandBuilder;
+    /**
+     * Add option to the command
+     */
     addOption(option: MessageCommandOptionBuilder | ((constructor: MessageCommandOptionBuilder) => MessageCommandOptionBuilder)): MessageCommandBuilder;
+    /**
+     * Validate options before executing
+     */
     setValidateOptions(validateOptions: boolean): MessageCommandBuilder;
+    /**
+     * validate given command options
+     */
     getCommandOptionValues(options: CommandMessage): MessageCommandValidatedOption[];
 }

package/bin/reciple/classes/builders/MessageCommandBuilder.js

@@ -7,6 +7,7 @@ class MessageCommandBuilder {
         this.builder = 'MESSAGE_COMMAND';
         this.name = '';
         this.description = '';
+        this.aliases = [];
         this.options = [];
         this.validateOptions = false;
         this.requiredPermissions = [];
@@ -14,42 +15,76 @@ class MessageCommandBuilder {
         this.allowExecuteByBots = false;
         this.execute = () => { };
     }
+    /**
+     * Sets the command name
+     */
     setName(name) {
         if (!name || typeof name !== 'string' || !name.match(/^[\w-]{1,32}$/))
             throw new TypeError('name must be a string and match the regex /^[\\w-]{1,32}$/');
         this.name = name;
         return this;
     }
+    /**
+     * Sets the command description
+     */
+    setDescription(description) {
+        if (!description || typeof description !== 'string')
+            throw new TypeError('description must be a string.');
+        this.description = description;
+        return this;
+    }
+    /**
+     * Add aliases to the command
+     */
+    addAliases(...aliases) {
+        if (!aliases.length)
+            throw new TypeError('Provide atleast one alias');
+        if (aliases.some(a => !a || typeof a !== 'string' || !a.match(/^[\w-]{1,32}$/)))
+            throw new TypeError('aliases must be strings and match the regex /^[\\w-]{1,32}$/');
+        if (this.name && aliases.some(a => a == this.name))
+            throw new TypeError('alias cannot have same name to its real command name');
+        this.aliases = [...new Set(aliases)];
+        return this;
+    }
+    /**
+     * Sets the default required permissions to execute this command
+     */
     setRequiredPermissions(permissions) {
         if (!permissions || !Array.isArray(permissions))
             throw new TypeError('permissions must be an array.');
         this.requiredPermissions = permissions;
         return this;
     }
+    /**
+     * Set if command can be executed in dms
+     */
     setAllowExecuteInDM(allowExecuteInDM) {
         if (typeof allowExecuteInDM !== 'boolean')
             throw new TypeError('allowExecuteInDM must be a boolean.');
         this.allowExecuteInDM = allowExecuteInDM;
         return this;
     }
+    /**
+     * Allow command to be executed by bots
+     */
     setAllowExecuteByBots(allowExecuteByBots) {
         if (typeof allowExecuteByBots !== 'boolean')
             throw new TypeError('allowExecuteByBots must be a boolean.');
         this.allowExecuteByBots = allowExecuteByBots;
         return this;
     }
-    setDescription(description) {
-        if (!description || typeof description !== 'string')
-            throw new TypeError('description must be a string.');
-        this.description = description;
-        return this;
-    }
+    /**
+     * Function when the command is executed
+     */
     setExecute(execute) {
         if (!execute || typeof execute !== 'function')
             throw new TypeError('execute must be a function.');
         this.execute = execute;
         return this;
     }
+    /**
+     * Add option to the command
+     */
     addOption(option) {
         if (!option)
             throw new TypeError('option must be a MessageOption.');
@@ -61,12 +96,18 @@ class MessageCommandBuilder {
         this.options = [...this.options, option];
         return this;
     }
+    /**
+     * Validate options before executing
+     */
     setValidateOptions(validateOptions) {
         if (typeof validateOptions !== 'boolean')
             throw new TypeError('validateOptions must be a boolean.');
         this.validateOptions = validateOptions;
         return this;
     }
+    /**
+     * validate given command options
+     */
     getCommandOptionValues(options) {
         const args = options.args || [];
         const required = this.options.filter(o => o.required);

package/bin/reciple/classes/builders/MessageCommandOptionBuilder.d.ts

@@ -3,8 +3,20 @@ export declare class MessageCommandOptionBuilder {
     description: string;
     required: boolean;
     validator: (value: string) => boolean;
+    /**
+     * Set command option name
+     */
     setName(name: string): MessageCommandOptionBuilder;
+    /**
+     * Set command option description
+     */
     setDescription(description: string): MessageCommandOptionBuilder;
+    /**
+     * Set if this option is required
+     */
     setRequired(required: boolean): MessageCommandOptionBuilder;
+    /**
+     * Set your custom function to validate given value for this option
+     */
     setValidator(validator: (value: string) => boolean): MessageCommandOptionBuilder;
 }

package/bin/reciple/classes/builders/MessageCommandOptionBuilder.js

@@ -8,24 +8,36 @@ class MessageCommandOptionBuilder {
         this.required = false;
         this.validator = () => true;
     }
+    /**
+     * Set command option name
+     */
     setName(name) {
         if (typeof name !== 'string' || !name.match(/^[\w-]{1,32}$/))
             throw new TypeError('name must be a string and match the regex /^[\\w-]{1,32}$/.');
         this.name = name;
         return this;
     }
+    /**
+     * Set command option description
+     */
     setDescription(description) {
         if (!description || typeof description !== 'string')
             throw new TypeError('description must be a string.');
         this.description = description;
         return this;
     }
+    /**
+     * Set if this option is required
+     */
     setRequired(required) {
         if (typeof required !== 'boolean')
             throw new TypeError('required must be a boolean.');
         this.required = required;
         return this;
     }
+    /**
+     * Set your custom function to validate given value for this option
+     */
     setValidator(validator) {
         if (!validator || typeof validator !== 'function')
             throw new TypeError('validator must be a function.');

package/bin/reciple/classes/builders/MessageCommandOptions.d.ts

@@ -1,8 +1,14 @@
 import { MessageCommandValidatedOption } from './MessageCommandBuilder';
 export declare class MessageCommandOptions extends Array<MessageCommandValidatedOption> {
     constructor(options: MessageCommandValidatedOption[]);
+    /**
+     * Get the option info
+     */
     get(name: string, requied: true): MessageCommandValidatedOption;
     get(name: string, requied?: boolean): MessageCommandValidatedOption | null;
+    /**
+     * Get the option value
+     */
     getValue(name: string, requied: true): string;
     getValue(name: string, requied?: boolean): string | null;
 }

package/bin/reciple/flags.d.ts

@@ -1,2 +1,8 @@
+/**
+ * Used flags
+ */
 export declare const flags: import("commander").OptionValues;
-export declare const token: any;
+/**
+ * Temporary token flag
+ */
+export declare const token: string | undefined;

package/bin/reciple/flags.js

@@ -2,10 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.token = exports.flags = void 0;
 const commander_1 = require("commander");
+/**
+ * Used flags
+ */
 exports.flags = commander_1.program
     .option('-t, --token <token>', 'Replace used bot token')
     .option('-c, --config <config>', 'Change path to config file')
     .option('-D, --debugmode', 'Enabled debug mode')
     .option('-v, --version', 'Display version')
     .parse().opts();
+/**
+ * Temporary token flag
+ */
 exports.token = exports.flags.token;

package/bin/reciple/hasPermissions.d.ts

@@ -1,4 +1,7 @@
 import { Permissions } from 'discord.js';
 import { recipleCommandBuilders } from './modules';
-import { Config } from './classes/Config';
+import { Config } from './classes/RecipleConfig';
+/**
+ * Check if the user has permissions to execute the given command name
+ */
 export declare function hasPermissions(commandName: string, memberPermissions?: Permissions, configConmmandPermissions?: Config['permissions']['messageCommands'] | Config['permissions']['interactionCommands'], builder?: recipleCommandBuilders): boolean;

package/bin/reciple/hasPermissions.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasPermissions = void 0;
+/**
+ * Check if the user has permissions to execute the given command name
+ */
 function hasPermissions(commandName, memberPermissions, configConmmandPermissions, builder) {
     var _a, _b;
     if (!(configConmmandPermissions === null || configConmmandPermissions === void 0 ? void 0 : configConmmandPermissions.enabled))

package/bin/reciple/isIgnoredChannel.d.ts

@@ -1,2 +1,5 @@
-import { Config } from './classes/Config';
+import { Config } from './classes/RecipleConfig';
+/**
+ * Check if the channel id is ignored in config file
+ */
 export declare function isIgnoredChannel(channelId: string, ignoredChannelsConfig?: Config["ignoredChannels"]): boolean;

package/bin/reciple/isIgnoredChannel.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isIgnoredChannel = void 0;
+/**
+ * Check if the channel id is ignored in config file
+ */
 function isIgnoredChannel(channelId, ignoredChannelsConfig) {
     if (!(ignoredChannelsConfig === null || ignoredChannelsConfig === void 0 ? void 0 : ignoredChannelsConfig.enabled))
         return false;

package/bin/reciple/logger.d.ts

@@ -1,2 +1,5 @@
 import { Logger } from 'fallout-utility';
-export declare function logger(stringifyJSON: boolean, debugmode?: boolean): Logger;
+/**
+ * Create new logger
+ */
+export declare function logger(stringifyJSON: boolean, debugmode?: boolean, colorizeMessage?: boolean): Logger;

package/bin/reciple/logger.js

@@ -1,13 +1,33 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.logger = void 0;
 const fallout_utility_1 = require("fallout-utility");
 const flags_1 = require("./flags");
-function logger(stringifyJSON, debugmode = false) {
-    return new fallout_utility_1.Logger("Main", {
-        addPrefixToEveryJsonNewLines: stringifyJSON,
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Create new logger
+ */
+function logger(stringifyJSON, debugmode = false, colorizeMessage = true) {
+    var _a;
+    return new fallout_utility_1.Logger({
         stringifyJSON: stringifyJSON,
-        setDebugging: flags_1.flags.debugmode || debugmode
+        enableDebugMode: (_a = flags_1.flags.debugmode) !== null && _a !== void 0 ? _a : debugmode,
+        loggerName: 'Main',
+        prefixes: {
+            [fallout_utility_1.LogLevels.INFO]: (name) => `[${chalk_1.default.bold("INFO" + (name ? chalk_1.default.dim(" - ") + name : ''))}]`,
+            [fallout_utility_1.LogLevels.WARN]: (name) => `[${chalk_1.default.bold.yellow("WARN" + (name ? chalk_1.default.dim(" - ") + name : ''))}]`,
+            [fallout_utility_1.LogLevels.ERROR]: (name) => `[${chalk_1.default.bold.red("ERROR" + (name ? chalk_1.default.dim(" - ") + name : ''))}]`,
+            [fallout_utility_1.LogLevels.DEBUG]: (name) => `[${chalk_1.default.bold.blue("DEBUG" + (name ? chalk_1.default.dim(" - ") + name : ''))}]`
+        },
+        colorMessages: {
+            [fallout_utility_1.LogLevels.INFO]: (message) => message,
+            [fallout_utility_1.LogLevels.WARN]: (message) => !colorizeMessage ? message : chalk_1.default.yellow(message),
+            [fallout_utility_1.LogLevels.ERROR]: (message) => !colorizeMessage ? message : chalk_1.default.red(message),
+            [fallout_utility_1.LogLevels.DEBUG]: (message) => !colorizeMessage ? message : chalk_1.default.blue(message)
+        }
     });
 }
 exports.logger = logger;

package/bin/reciple/modules.d.ts

@@ -21,4 +21,7 @@ export interface RecipleModule {
         path?: string;
     };
 }
-export declare function loadModules(client: RecipleClient): Promise<loadedModules>;
+/**
+ * Load modules from folder
+ */
+export declare function loadModules(client: RecipleClient, folder?: string): Promise<loadedModules>;

package/bin/reciple/modules.js

@@ -17,12 +17,14 @@ const fs_1 = require("fs");
 const version_1 = require("./version");
 const wildcard_match_1 = __importDefault(require("wildcard-match"));
 const path_1 = __importDefault(require("path"));
-function loadModules(client) {
+/**
+ * Load modules from folder
+ */
+function loadModules(client, folder) {
     var _a, _b;
     return __awaiter(this, void 0, void 0, function* () {
         const response = { commands: [], modules: [] };
-        const modulesDir = client.config.modulesFolder || './modules';
-        const logger = client.logger;
+        const modulesDir = client.config.modulesFolder || folder || './modules';
         if (!(0, fs_1.existsSync)(modulesDir))
             (0, fs_1.mkdirSync)(modulesDir, { recursive: true });
         const ignoredFiles = (client.config.ignoredFiles || []).map(file => file.endsWith('.js') ? file : `${file}.js`);
@@ -51,17 +53,21 @@ function loadModules(client) {
                 }
             }
             catch (error) {
-                logger.error(`Failed to load module ${script}`);
-                logger.error(error);
+                if (client.isClientLogsEnabled()) {
+                    client.logger.error(`Failed to load module ${script}`);
+                    client.logger.error(error);
+                }
                 continue;
             }
             response.commands.push(...commands.filter((c) => {
                 if (!c.name) {
-                    logger.error(`A ${c.builder} command name is not defined in ${script}`);
+                    if (client.isClientLogsEnabled())
+                        client.logger.error(`A ${c.builder} command name is not defined in ${script}`);
                     return false;
                 }
                 if (c.builder === 'MESSAGE_COMMAND' && c.options.length && c.options.some(o => !o.name)) {
-                    logger.error(`A ${c.builder} option name is not defined in ${script}`);
+                    if (client.isClientLogsEnabled())
+                        client.logger.error(`A ${c.builder} option name is not defined in ${script}`);
                     return false;
                 }
                 return true;
@@ -74,7 +80,8 @@ function loadModules(client) {
                     path: modulePath
                 }
             });
-            logger.info(`Loaded module ${script}`);
+            if (client.isClientLogsEnabled())
+                client.logger.info(`Loaded module ${script}`);
         }
         return response;
     });

package/bin/reciple/registerInteractionCommands.d.ts

@@ -3,4 +3,7 @@ import { ApplicationCommandDataResolvable } from 'discord.js';
 import { RecipleClient } from './classes/RecipleClient';
 import { ContextMenuCommandBuilder, SlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandOptionsOnlyBuilder, SlashCommandSubcommandGroupBuilder, SlashCommandSubcommandsOnlyBuilder } from '@discordjs/builders';
 export declare type interactionCommandBuilders = InteractionCommandBuilder | ContextMenuCommandBuilder | SlashCommandBuilder | SlashCommandSubcommandBuilder | SlashCommandOptionsOnlyBuilder | SlashCommandSubcommandGroupBuilder | SlashCommandSubcommandsOnlyBuilder;
+/**
+ * Register interaction commands
+ */
 export declare function registerInteractionCommands(client: RecipleClient, cmds?: (interactionCommandBuilders | ApplicationCommandDataResolvable)[], overwriteGuilds?: string | string[]): Promise<void>;

package/bin/reciple/registerInteractionCommands.js

@@ -10,6 +10,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerInteractionCommands = void 0;
+/**
+ * Register interaction commands
+ */
 function registerInteractionCommands(client, cmds, overwriteGuilds) {
     var _a, _b, _c;
     return __awaiter(this, void 0, void 0, function* () {
@@ -24,7 +27,8 @@ function registerInteractionCommands(client, cmds, overwriteGuilds) {
                     undefined)) !== null && _d !== void 0 ? _d : cmd.requiredPermissions;
                 cmd.setRequiredPermissions(permissions);
                 client.commands.INTERACTION_COMMANDS[cmd.name] = cmd;
-                client.logger.debug(`Set required permissions for ${cmd.name}`);
+                if (client.isClientLogsEnabled())
+                    client.logger.debug(`Set required permissions for ${cmd.name}`);
                 return cmd.toJSON();
             }
             return c.toJSON();
@@ -33,17 +37,20 @@ function registerInteractionCommands(client, cmds, overwriteGuilds) {
         const guilds = typeof configGuilds === 'object' ? configGuilds : [configGuilds];
         if (!guilds || !(guilds === null || guilds === void 0 ? void 0 : guilds.length)) {
             (_b = client.application) === null || _b === void 0 ? void 0 : _b.commands.set(commands).then(() => {
-                client.logger.warn('No guilds were specified for interaction commands. Registered commands for all guilds.');
-            }).catch(e => client.logger.error(e));
+                if (client.isClientLogsEnabled())
+                    client.logger.warn('No guilds were specified for interaction commands. Registered interaction commands globally.');
+            });
         }
         else {
-            client.logger.warn(`Registering ${commands.length} interaction commands to ${guilds.length} guild(s).`);
+            if (client.isClientLogsEnabled())
+                client.logger.warn(`Registering ${commands.length} interaction commands to ${guilds.length} guild(s).`);
             for (const guild of guilds) {
                 if (!guild)
                     continue;
                 (_c = client.application) === null || _c === void 0 ? void 0 : _c.commands.set(commands, guild).then(() => {
-                    client.logger.warn(`Registered ${commands.length} interaction command(s) for ${guild}.`);
-                }).catch(e => client.logger.error(e));
+                    if (client.isClientLogsEnabled())
+                        client.logger.warn(`Registered ${commands.length} interaction command(s) for ${guild}.`);
+                });
             }
         }
     });

package/bin/reciple/version.d.ts

@@ -1,8 +1,20 @@
+/**
+ * Current reciple version
+ */
 export declare const version: string;
+/**
+ * Check if the version is valid
+ */
 export declare function isValidVersion(ver: string): boolean;
+/**
+ * Parse the version string
+ */
 export declare function parseVersion(ver: string): {
     major: number;
     minor: number;
     patch: number;
 };
+/**
+ * Check if the given version is supported by the given version range
+ */
 export declare function isSupportedVersion(versionRange: string, supportedVersion?: string): boolean;

package/bin/reciple/version.js

@@ -5,11 +5,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSupportedVersion = exports.parseVersion = exports.isValidVersion = exports.version = void 0;
 const semver_1 = __importDefault(require("semver"));
+/**
+ * Current reciple version
+ */
 exports.version = require('../../package.json').version;
+/**
+ * Check if the version is valid
+ */
 function isValidVersion(ver) {
     return semver_1.default.valid(semver_1.default.coerce(ver)) !== null;
 }
 exports.isValidVersion = isValidVersion;
+/**
+ * Parse the version string
+ */
 function parseVersion(ver) {
     var _a, _b;
     if (!isValidVersion(ver))
@@ -18,6 +27,9 @@ function parseVersion(ver) {
     return { major: parseInt(major), minor: parseInt(minor), patch: parseInt(patch) };
 }
 exports.parseVersion = parseVersion;
+/**
+ * Check if the given version is supported by the given version range
+ */
 function isSupportedVersion(versionRange, supportedVersion) {
     supportedVersion = supportedVersion || exports.version;
     if (!isValidVersion(versionRange))

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "reciple",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "A Discord.js bot",
   "author": "FalloutStudios",
+  "homepage": "https://falloutstudios.github.io/Reciple",
   "license": "GPL-3.0",
   "main": "bin/index.js",
   "bin": {
@@ -22,14 +23,17 @@
     "clean": "rm -rf bin",
     "build": "yarn clean && npx tsc && npm un reciple -g && npm i ./ -g",
     "build:publish": "yarn run build && yarn publish",
-    "test": "yarn run build && yarn test:run",
-    "test:start": "cd test && npx reciple"
+    "test": "yarn run build && yarn test:start",
+    "test:start": "cd test && npx reciple",
+    "postpublish": "yarn build:docs && yarn update:docs",
+    "build:docs": "cd docs && yarn build",
+    "update:docs": "cd docs && yarn update"
   },
   "dependencies": {
+    "chalk": "4.1.2",
     "commander": "^9.3.0",
-    "discord.js": "^13.8.1",
     "dotenv": "^16.0.1",
-    "fallout-utility": "^1.3.14",
+    "fallout-utility": "^1.4.2",
     "semver": "^7.3.7",
     "wildcard-match": "^5.1.2",
     "yaml": "^2.1.1"
@@ -37,6 +41,10 @@
   "devDependencies": {
     "@types/node": "^18.0.0",
     "@types/semver": "^7.3.10",
+    "discord.js": "^13.8.1",
     "typescript": "^4.7.4"
+  },
+  "peerDependencies": {
+    "discord.js": "13.8.x"
   }
 }

package/resource/reciple.yml

@@ -13,6 +13,8 @@ commands:
     enabled: true
     # reply when an error occured
     replyOnError: false
+    # Allow executing commands via aliases
+    allowCommandAlias: false
     # command argument separator
     commandArgumentSeparator: ' '
   interactionCommand:
@@ -60,6 +62,8 @@ fileLogging:
   enabled: true
   # enable debug mode
   debugmode: false
+  # enable if reciple will use the logger
+  clientLogs: true
   # stringify logged JSONs
   stringifyLoggedJSON: false
   # log file path