feat(*): Began working on other punishment commands etc

24 files changed, 607 insertions, 366 deletions

diff --git a/src/commands/config/muteRole.ts b/src/commands/config/muteRole.ts
new file mode 100644
index 0000000..f51c5ce
--- /dev/null
+++ b/src/commands/config/muteRole.ts
@@ -0,0 +1,57 @@
+import { Role } from 'discord.js';
+import { BushCommand } from '../../lib/extensions/BushCommand';
+import { BushSlashMessage } from '../../lib/extensions/BushInteractionMessage';
+import { BushMessage } from '../../lib/extensions/BushMessage';
+import { Guild } from '../../lib/models';
+import AllowedMentions from '../../lib/utils/AllowedMentions';
+
+export default class MuteRoleCommand extends BushCommand {
+	constructor() {
+		super('muteRole', {
+			aliases: ['muterole'],
+			category: 'config',
+			description: {
+				content: 'Set the prefix of the current server (resets to default if prefix is not given)',
+				usage: 'prefix [prefix]',
+				examples: ['prefix', 'prefix +']
+			},
+			clientPermissions: ['SEND_MESSAGES'],
+			userPermissions: ['SEND_MESSAGES', 'MANAGE_GUILD'],
+			args: [
+				{
+					id: 'role',
+					type: 'role',
+					prompt: {
+						start: "What would you like to set the server's mute role to?",
+						retry: '{error} Choose a valid role.',
+						optional: false
+					}
+				}
+			],
+			slash: true,
+			slashOptions: [
+				{
+					type: 'ROLE',
+					name: 'role',
+					description: 'The mute role for this server.',
+					required: true
+				}
+			]
+		});
+	}
+
+	async exec(message: BushMessage | BushSlashMessage, args: { role: Role }): Promise<void> {
+		let row = await Guild.findByPk(message.guild.id);
+		if (!row) {
+			row = Guild.build({
+				id: message.guild.id
+			});
+		}
+		row.muteRole = args.role.id;
+		await row.save();
+		await message.util.send({
+			content: `${this.client.util.emojis.success} Changed the mute role to <@&${args.role.id}>.`,
+			allowedMentions: AllowedMentions.none()
+		});
+	}
+}
diff --git a/src/commands/config/prefix.ts b/src/commands/config/prefix.ts
index 1326426..5b73a1a 100644
--- a/src/commands/config/prefix.ts
+++ b/src/commands/config/prefix.ts
@@ -1,6 +1,6 @@
-import { Message } from 'discord.js';
 import { BushCommand } from '../../lib/extensions/BushCommand';
 import { BushSlashMessage } from '../../lib/extensions/BushInteractionMessage';
+import { BushMessage } from '../../lib/extensions/BushMessage';
 import { Guild } from '../../lib/models';
 
 export default class PrefixCommand extends BushCommand {
@@ -11,10 +11,16 @@ export default class PrefixCommand extends BushCommand {
 			args: [
 				{
 					id: 'prefix',
-					type: 'string'
+					type: 'string',
+					prompt: {
+						start: 'What would you like the new prefix to be?',
+						retry: '{error} Choose a valid prefix',
+						optional: true
+					}
 				}
 			],
-			userPermissions: ['MANAGE_GUILD'],
+			clientPermissions: ['SEND_MESSAGES'],
+			userPermissions: ['SEND_MESSAGES', 'MANAGE_GUILD'],
 			description: {
 				content: 'Set the prefix of the current server (resets to default if prefix is not given)',
 				usage: 'prefix [prefix]',
@@ -32,7 +38,7 @@ export default class PrefixCommand extends BushCommand {
 		});
 	}
 
-	async exec(message: Message | BushSlashMessage, { prefix }: { prefix?: string }): Promise<void> {
+	async exec(message: BushMessage | BushSlashMessage, { prefix }: { prefix?: string }): Promise<void> {
 		let row = await Guild.findByPk(message.guild.id);
 		if (!row) {
 			row = Guild.build({
@@ -41,7 +47,7 @@ export default class PrefixCommand extends BushCommand {
 		}
 		await row.update({ prefix: prefix || this.client.config.prefix });
 		if (prefix) {
-			await message.util.send(`${this.client.util.emojis.success} changed prefix from \`${prefix}\``);
+			await message.util.send(`${this.client.util.emojis.success} changed prefix from \`${prefix}\` to `);
 		} else {
 			await message.util.send(`${this.client.util.emojis.success} reset prefix to \`${this.client.config.prefix}\``);
 		}
diff --git a/src/commands/config/welcomeChannel.ts b/src/commands/config/welcomeChannel.ts
new file mode 100644
index 0000000..72e55f1
--- /dev/null
+++ b/src/commands/config/welcomeChannel.ts
@@ -0,0 +1,49 @@
+import { User } from 'discord.js';
+import { BushCommand } from '../../lib/extensions/BushCommand';
+import { BushMessage } from '../../lib/extensions/BushMessage';
+import { Global } from '../../lib/models';
+
+export default class WelcomeChannelCommand extends BushCommand {
+	public constructor() {
+		super('welcomeChannel', {
+			aliases: ['welcomechannel', 'wc'],
+			category: 'config',
+			description: {
+				content: 'Configure the what channel you want the bot to send a message in when someone joins the server.',
+				usage: 'welcomechannel [channel]',
+				examples: ['welcomechannel #welcome']
+			},
+			clientPermissions: ['SEND_MESSAGES'],
+			ownerOnly: true
+		});
+	}
+	public async exec(message: BushMessage, args: { action: 'add' | 'remove'; user: User }): Promise<unknown> {
+		if (!this.client.config.owners.includes(message.author.id))
+			return await message.util.reply(`${this.client.util.emojis.error} Only my developers can run this command...`);
+
+		const superUsers = (await Global.findByPk(this.client.config.dev ? 'development' : 'production')).superUsers;
+		let success;
+		if (args.action === 'add') {
+			if (superUsers.includes(args.user.id)) {
+				return message.util.reply(`${this.client.util.emojis.warn} \`${args.user.tag}\` is already a superuser.`);
+			}
+			success = await this.client.util.insertOrRemoveFromGlobal('add', 'superUsers', args.user.id).catch(() => false);
+		} else {
+			if (!superUsers.includes(args.user.id)) {
+				return message.util.reply(`${this.client.util.emojis.warn} \`${args.user.tag}\` is not superuser.`);
+			}
+			success = await this.client.util.insertOrRemoveFromGlobal('remove', 'superUsers', args.user.id).catch(() => false);
+		}
+		if (success) {
+			const responses = [args.action == 'remove' ? `` : 'made', args.action == 'remove' ? 'is no longer' : ''];
+			return message.util.reply(
+				`${this.client.util.emojis.success} ${responses[0]} \`${args.user.tag}\` ${responses[1]} a superuser.`
+			);
+		} else {
+			const response = [args.action == 'remove' ? `removing` : 'making', args.action == 'remove' ? `from` : 'to'];
+			return message.util.reply(
+				`${this.client.util.emojis.error} There was an error ${response[0]} \`${args.user.tag}\` ${response[1]} the superuser list.`
+			);
+		}
+	}
+}
diff --git a/src/commands/dev/eval.ts b/src/commands/dev/eval.ts
index d2fe432..310a2c5 100644
--- a/src/commands/dev/eval.ts
+++ b/src/commands/dev/eval.ts
@@ -10,7 +10,7 @@ import { BushMessage } from '../../lib/extensions/BushMessage';
 
 const clean = (text) => {
 	if (typeof text === 'string') {
-		return (text = Util.cleanCodeBlockContent(text));
+		return Util.cleanCodeBlockContent(text);
 	} else return text;
 };
 const sh = promisify(exec);
@@ -186,7 +186,7 @@ export default class EvalCommand extends BushCommand {
 				{ Global } = await import('../../lib/models/Global'),
 				{ Guild } = await import('../../lib/models/Guild'),
 				{ Level } = await import('../../lib/models/Level'),
-				{ Modlog } = await import('../../lib/models/Modlog'),
+				{ ModLog } = await import('../../lib/models/ModLog'),
 				{ StickyRole } = await import('../../lib/models/StickyRole');
 			if (code[code.lang].replace(/ /g, '').includes('9+10' || '10+9')) {
 				output = 21;
diff --git a/src/commands/dev/reload.ts b/src/commands/dev/reload.ts
index 94e31b0..f5fee88 100644
--- a/src/commands/dev/reload.ts
+++ b/src/commands/dev/reload.ts
@@ -1,6 +1,5 @@
 import { stripIndent } from 'common-tags';
 import { Message } from 'discord.js';
-import { SlashCommandOption } from '../../lib/extensions/BushClientUtil';
 import { BushCommand } from '../../lib/extensions/BushCommand';
 import { BushSlashMessage } from '../../lib/extensions/BushInteractionMessage';
 
@@ -51,11 +50,7 @@ export default class ReloadCommand extends BushCommand {
 		}
 	}
 
-	public async exec(message: Message, { fast }: { fast: boolean }): Promise<void> {
+	public async exec(message: Message | BushSlashMessage, { fast }: { fast: boolean }): Promise<void> {
 		await message.util.send(await this.getResponse(fast));
 	}
-
-	public async execSlash(message: BushSlashMessage, { fast }: { fast: SlashCommandOption<boolean> }): Promise<void> {
-		await message.interaction.reply(await this.getResponse(fast?.value));
-	}
 }
diff --git a/src/commands/dev/setLevel.ts b/src/commands/dev/setLevel.ts
index ca555db..f536109 100644
--- a/src/commands/dev/setLevel.ts
+++ b/src/commands/dev/setLevel.ts
@@ -1,7 +1,5 @@
 import { Message, User } from 'discord.js';
-import { SlashCommandOption } from '../../lib/extensions/BushClientUtil';
 import { BushCommand } from '../../lib/extensions/BushCommand';
-import { BushSlashMessage } from '../../lib/extensions/BushInteractionMessage';
 import { Level } from '../../lib/models';
 import AllowedMentions from '../../lib/utils/AllowedMentions';
 
@@ -71,14 +69,4 @@ export default class SetLevelCommand extends BushCommand {
 			allowedMentions: AllowedMentions.none()
 		});
 	}
-
-	async execSlash(
-		message: BushSlashMessage,
-		{ user, level }: { user: SlashCommandOption<void>; level: SlashCommandOption<number> }
-	): Promise<void> {
-		await message.interaction.reply({
-			content: await this.setLevel(user.user, level.value),
-			allowedMentions: AllowedMentions.none()
-		});
-	}
 }
diff --git a/src/commands/dev/superUser.ts b/src/commands/dev/superUser.ts
index c3ed0b0..4562e6f 100644
--- a/src/commands/dev/superUser.ts
+++ b/src/commands/dev/superUser.ts
@@ -2,7 +2,7 @@ import { Constants } from 'discord-akairo';
 import { User } from 'discord.js';
 import { BushCommand } from '../../lib/extensions/BushCommand';
 import { BushMessage } from '../../lib/extensions/BushMessage';
-import { Global } from '../../lib/models/Global';
+import { Global } from '../../lib/models';
 
 export default class SuperUserCommand extends BushCommand {
 	public constructor() {
diff --git a/src/commands/info/botInfo.ts b/src/commands/info/botInfo.ts
index 120527d..3db4151 100644
--- a/src/commands/info/botInfo.ts
+++ b/src/commands/info/botInfo.ts
@@ -1,7 +1,6 @@
 import { Message, MessageEmbed } from 'discord.js';
 import { duration } from 'moment';
 import { BushCommand } from '../../lib/extensions/BushCommand';
-import { BushSlashMessage } from '../../lib/extensions/BushInteractionMessage';
 
 export default class BotInfoCommand extends BushCommand {
 	constructor() {
@@ -13,11 +12,13 @@ export default class BotInfoCommand extends BushCommand {
 				usage: 'botinfo',
 				examples: ['botinfo']
 			},
-			slash: true
+			slash: true,
+			clientPermissions: ['SEND_MESSAGES', 'EMBED_LINKS'],
+			userPermissions: ['SEND_MESSAGES']
 		});
 	}
 
-	private async generateEmbed(): Promise<MessageEmbed> {
+	public async exec(message: Message): Promise<void> {
 		const owners = (await this.client.util.mapIDs(this.client.ownerID)).map((u) => u.tag).join('\n');
 		const currentCommit = (await this.client.util.shell('git rev-parse HEAD')).stdout.replace('\n', '');
 		const repoUrl = (await this.client.util.shell('git remote get-url origin')).stdout.replace('\n', '');
@@ -44,14 +45,6 @@ export default class BotInfoCommand extends BushCommand {
 				}
 			])
 			.setTimestamp();
-		return embed;
-	}
-
-	public async exec(message: Message): Promise<void> {
-		await message.util.send({ embeds: [await this.generateEmbed()] });
-	}
-
-	public async execSlash(message: BushSlashMessage): Promise<void> {
-		await message.interaction.reply({ embeds: [await this.generateEmbed()] });
+		await message.util.reply({ embeds: [embed] });
 	}
 }
diff --git a/src/commands/info/help.ts b/src/commands/info/help.ts
index 0efc6b3..8969efc 100644
--- a/src/commands/info/help.ts
+++ b/src/commands/info/help.ts
@@ -14,6 +14,7 @@ export default class HelpCommand extends BushCommand {
 				examples: ['help prefix']
 			},
 			clientPermissions: ['EMBED_LINKS'],
+
 			args: [
 				{
 					id: 'command',
@@ -31,15 +32,15 @@ export default class HelpCommand extends BushCommand {
 					flag: '--hidden'
 				}
 			],
+			slash: true,
 			slashOptions: [
 				{
 					type: 'STRING',
 					name: 'command',
-					description: `The command you would like to find information about.`,
+					description: 'The command you would like to find information about.',
 					required: false
 				}
-			],
-			slash: true
+			]
 		});
 	}
 
@@ -79,8 +80,7 @@ export default class HelpCommand extends BushCommand {
 					if (command.superUserOnly && !isSuperUser) {
 						return false;
 					}
-					if (command.restrictedGuilds?.includes(message.guild.id) == !true && !args.showHidden) return false;
-					return true;
+					return !(command.restrictedGuilds?.includes(message.guild.id) == false && !args.showHidden);
 				});
 				const categoryNice = category.id
 					.replace(/(\b\w)/gi, (lc): string => lc.toUpperCase())
diff --git a/src/commands/info/ping.ts b/src/commands/info/ping.ts
index e80cfb3..3038658 100644
--- a/src/commands/info/ping.ts
+++ b/src/commands/info/ping.ts
@@ -12,6 +12,8 @@ export default class PingCommand extends BushCommand {
 				usage: 'ping',
 				examples: ['ping']
 			},
+			clientPermissions: ['SEND_MESSAGES', 'EMBED_LINKS'],
+			userPermissions: ['SEND_MESSAGES'],
 			slash: true
 		});
 	}
diff --git a/src/commands/info/pronouns.ts b/src/commands/info/pronouns.ts
index 79baeef..2175233 100644
--- a/src/commands/info/pronouns.ts
+++ b/src/commands/info/pronouns.ts
@@ -1,8 +1,6 @@
 import { CommandInteraction, Message, MessageEmbed, User } from 'discord.js';
 import got, { HTTPError } from 'got';
-import { SlashCommandOption } from '../../lib/extensions/BushClientUtil';
 import { BushCommand } from '../../lib/extensions/BushCommand';
-import { BushSlashMessage } from '../../lib/extensions/BushInteractionMessage';
 
 export const pronounMapping = {
 	unspecified: 'Unspecified',
@@ -55,7 +53,6 @@ export default class PronounsCommand extends BushCommand {
 					required: false
 				}
 			],
-			slashEphemeral: true, // I'll add dynamic checking to this later
 			slash: true
 		});
 	}
@@ -107,8 +104,4 @@ export default class PronounsCommand extends BushCommand {
 		const u = user || message.author;
 		await this.sendResponse(message, u, u.id === message.author.id);
 	}
-	async execSlash(message: BushSlashMessage, { user }: { user?: SlashCommandOption<void> }): Promise<void> {
-		const u = user?.user || message.author;
-		await this.sendResponse(message.interaction, u, u.id === message.author.id);
-	}
 }
diff --git a/src/commands/moderation/ban.ts b/src/commands/moderation/ban.ts
index 692691e..7ce222a 100644
--- a/src/commands/moderation/ban.ts
+++ b/src/commands/moderation/ban.ts
@@ -1,18 +1,17 @@
+import { Argument } from 'discord-akairo';
 import { CommandInteraction, Message, User } from 'discord.js';
 import moment from 'moment';
-import { SlashCommandOption } from '../../lib/extensions/BushClientUtil';
 import { BushCommand } from '../../lib/extensions/BushCommand';
-import { BushSlashMessage } from '../../lib/extensions/BushInteractionMessage';
-import { Ban, Guild, Modlog, ModlogType } from '../../lib/models';
+import { Ban, Guild, ModLog, ModLogType } from '../../lib/models';
 
-const durationAliases: Record<string, string[]> = {
+/* const durationAliases: Record<string, string[]> = {
 	weeks: ['w', 'weeks', 'week', 'wk', 'wks'],
 	days: ['d', 'days', 'day'],
 	hours: ['h', 'hours', 'hour', 'hr', 'hrs'],
 	minutes: ['m', 'min', 'mins', 'minutes', 'minute'],
 	months: ['mo', 'month', 'months']
 };
-const durationRegex = /(?:(\d+)(d(?:ays?)?|h(?:ours?|rs?)?|m(?:inutes?|ins?)?|mo(?:nths?)?|w(?:eeks?|ks?)?)(?: |$))/g;
+const durationRegex = /(?:(\d+)(d(?:ays?)?|h(?:ours?|rs?)?|m(?:inutes?|ins?)?|mo(?:nths?)?|w(?:eeks?|ks?)?)(?: |$))/g; */
 
 export default class BanCommand extends BushCommand {
 	constructor() {
@@ -25,15 +24,21 @@ export default class BanCommand extends BushCommand {
 					type: 'user',
 					prompt: {
 						start: 'What user would you like to ban?',
-						retry: 'Invalid response. What user would you like to ban?'
+						retry: '{error} Choose a valid user to ban.'
 					}
 				},
 				{
 					id: 'reason',
-					match: 'rest'
+					match: 'restContent',
+					prompt: {
+						start: 'Why would you like to ban this user?',
+						retry: '{error} Choose a ban reason.',
+						optional: true
+					}
 				},
 				{
 					id: 'time',
+					type: 'duration',
 					match: 'option',
 					flag: '--time'
 				}
@@ -41,27 +46,27 @@ export default class BanCommand extends BushCommand {
 			clientPermissions: ['BAN_MEMBERS'],
 			userPermissions: ['BAN_MEMBERS'],
 			description: {
-				content: 'Ban a member and log it in modlogs (with optional time to unban)',
+				content: 'Ban a member from the server.',
 				usage: 'ban <member> <reason> [--time]',
-				examples: ['ban @Tyman being cool', 'ban @Tyman being cool --time 7days']
+				examples: ['ban @user bad --time 69d']
 			},
 			slashOptions: [
 				{
 					type: 'USER',
 					name: 'user',
-					description: 'The user to ban',
+					description: 'Who would you like to ban?',
 					required: true
 				},
 				{
 					type: 'STRING',
 					name: 'reason',
-					description: 'The reason to show in modlogs and audit log',
+					description: 'Why are they getting banned?',
 					required: false
 				},
 				{
 					type: 'STRING',
 					name: 'time',
-					description: 'The time the user should be banned for (default permanent)',
+					description: 'How long should they be banned for?',
 					required: false
 				}
 			],
@@ -72,12 +77,12 @@ export default class BanCommand extends BushCommand {
 		message: Message | CommandInteraction,
 		user: User,
 		reason?: string,
-		time?: string
+		time?: number
 	): AsyncIterable<string> {
 		const duration = moment.duration();
-		let modlogEnry: Modlog;
+		let modLogEntry: ModLog;
 		let banEntry: Ban;
-		const translatedTime: string[] = [];
+		// const translatedTime: string[] = [];
 		// Create guild entry so postgres doesn't get mad when I try and add a modlog entry
 		await Guild.findOrCreate({
 			where: {
@@ -88,62 +93,58 @@ export default class BanCommand extends BushCommand {
 			}
 		});
 		try {
-			try {
-				if (time) {
-					const parsed = [...time.matchAll(durationRegex)];
+			if (time) {
+				duration.add(time);
+				/* 	const parsed = [...time.matchAll(durationRegex)];
 					if (parsed.length < 1) {
-						yield 'Invalid time.';
+						yield `${this.client.util.emojis.error} Invalid time.`;
 						return;
 					}
 					for (const part of parsed) {
 						const translated = Object.keys(durationAliases).find((k) => durationAliases[k].includes(part[2]));
 						translatedTime.push(part[1] + ' ' + translated);
 						duration.add(Number(part[1]), translated as 'weeks' | 'days' | 'hours' | 'months' | 'minutes');
-					}
-					modlogEnry = Modlog.build({
-						user: user.id,
-						guild: message.guild.id,
-						reason,
-						type: ModlogType.TEMPBAN,
-						duration: duration.asMilliseconds(),
-						moderator: message instanceof CommandInteraction ? message.user.id : message.author.id
-					});
-					banEntry = Ban.build({
-						user: user.id,
-						guild: message.guild.id,
-						reason,
-						expires: new Date(new Date().getTime() + duration.asMilliseconds()),
-						modlog: modlogEnry.id
-					});
-				} else {
-					modlogEnry = Modlog.build({
-						user: user.id,
-						guild: message.guild.id,
-						reason,
-						type: ModlogType.BAN,
-						moderator: message instanceof CommandInteraction ? message.user.id : message.author.id
-					});
-					banEntry = Ban.build({
-						user: user.id,
-						guild: message.guild.id,
-						reason,
-						modlog: modlogEnry.id
-					});
-				}
-				await modlogEnry.save();
-				await banEntry.save();
-			} catch (e) {
-				this.client.console.error(`BanCommand`, `Error saving to database. ${e?.stack}`);
-				yield `${this.client.util.emojis.error} Error saving to database. Please report this to a developer.`;
-				return;
+					} */
+				modLogEntry = ModLog.build({
+					user: user.id,
+					guild: message.guild.id,
+					reason,
+					type: ModLogType.TEMP_BAN,
+					duration: duration.asMilliseconds(),
+					moderator: message instanceof CommandInteraction ? message.user.id : message.author.id
+				});
+				banEntry = Ban.build({
+					user: user.id,
+					guild: message.guild.id,
+					reason,
+					expires: new Date(new Date().getTime() + duration.asMilliseconds()),
+					modlog: modLogEntry.id
+				});
+			} else {
+				modLogEntry = ModLog.build({
+					user: user.id,
+					guild: message.guild.id,
+					reason,
+					type: ModLogType.BAN,
+					moderator: message instanceof CommandInteraction ? message.user.id : message.author.id
+				});
+				banEntry = Ban.build({
+					user: user.id,
+					guild: message.guild.id,
+					reason,
+					modlog: modLogEntry.id
+				});
 			}
+			await modLogEntry.save();
+			await banEntry.save();
+
 			try {
 				await user.send(
-					`You were banned in ${message.guild.name} ${
-						translatedTime.length >= 1 ? `for ${translatedTime.join(', ')}` : 'permanently'
-					} with reason \`${reason || 'No reason given'}\``
+					`You were banned in ${message.guild.name} ${duration ? duration.humanize() : 'permanently'} with reason \`${
+						reason || 'No reason given'
+					}\``
 				);
-			} catch (e) {
+			} catch {
 				yield `${this.client.util.emojis.warn} Unable to dm user`;
 			}
 			await message.guild.members.ban(user, {
@@ -152,35 +153,22 @@ export default class BanCommand extends BushCommand {
 				}`
 			});
 			yield `${this.client.util.emojis.success} Banned <@!${user.id}> ${
-				translatedTime.length >= 1 ? `for ${translatedTime.join(', ')}` : 'permanently'
+				duration ? duration.humanize() : 'permanently'
 			} with reason \`${reason || 'No reason given'}\``;
 		} catch {
 			yield `${this.client.util.emojis.error} Error banning :/`;
 			await banEntry.destroy();
-			await modlogEnry.destroy();
+			await modLogEntry.destroy();
 			return;
 		}
 	}
-	async exec(message: Message, { user, reason, time }: { user: User; reason?: string; time?: string }): Promise<void> {
+	async exec(message: Message, { user, reason, time }: { user: User; reason?: string; time?: number | string }): Promise<void> {
+		if (typeof time === 'string') {
+			time = (await Argument.cast('duration', this.client.commandHandler.resolver, message, time)) as number;
+			//// time = this.client.commandHandler.resolver.type('duration')
+		}
 		for await (const response of this.genResponses(message, user, reason, time)) {
 			await message.util.send(response);
 		}
 	}
-
-	async execSlash(
-		message: BushSlashMessage,
-		{
-			user,
-			reason,
-			time
-		}: {
-			user: SlashCommandOption<undefined>;
-			reason: SlashCommandOption<string>;
-			time: SlashCommandOption<string>;
-		}
-	): Promise<void> {
-		for await (const response of this.genResponses(message.interaction, user.user, reason?.value, time?.value)) {
-			await message.reply(response);
-		}
-	}
 }
diff --git a/src/commands/moderation/block.ts b/src/commands/moderation/block.ts
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/commands/moderation/block.ts
diff --git a/src/commands/moderation/kick.ts b/src/commands/moderation/kick.ts
index d00ae55..eed3038 100644
--- a/src/commands/moderation/kick.ts
+++ b/src/commands/moderation/kick.ts
@@ -1,7 +1,7 @@
 import { CommandInteraction, GuildMember, Message } from 'discord.js';
 import { BushCommand } from '../../lib/extensions/BushCommand';
 import { BushSlashMessage } from '../../lib/extensions/BushInteractionMessage';
-import { Guild, Modlog, ModlogType } from '../../lib/models';
+import { Guild, ModLog, ModLogType } from '../../lib/models';
 
 export default class KickCommand extends BushCommand {
 	constructor() {
@@ -14,17 +14,19 @@ export default class KickCommand extends BushCommand {
 					type: 'member',
 					prompt: {
 						start: 'What user would you like to kick?',
-						retry: 'Invalid response. What user would you like to kick?'
+						retry: '{error} Choose a valid user to kick.'
 					}
 				},
 				{
-					id: 'reason'
+					id: 'reason',
+					type: 'string',
+					match: 'restContent'
 				}
 			],
 			clientPermissions: ['KICK_MEMBERS'],
 			userPermissions: ['KICK_MEMBERS'],
 			description: {
-				content: 'Kick a member and log it in modlogs',
+				content: 'Kick a member from the server.',
 				usage: 'kick <member> <reason>',
 				examples: ['kick @Tyman being cool']
 			},
@@ -51,7 +53,7 @@ export default class KickCommand extends BushCommand {
 		user: GuildMember,
 		reason?: string
 	): AsyncIterable<string> {
-		let modlogEnry: Modlog;
+		let modlogEnry: ModLog;
 		// Create guild entry so postgres doesn't get mad when I try and add a modlog entry
 		await Guild.findOrCreate({
 			where: {
@@ -62,16 +64,16 @@ export default class KickCommand extends BushCommand {
 			}
 		});
 		try {
-			modlogEnry = Modlog.build({
+			modlogEnry = ModLog.build({
 				user: user.id,
 				guild: message.guild.id,
 				moderator: message instanceof Message ? message.author.id : message.user.id,
-				type: ModlogType.KICK,
+				type: ModLogType.KICK,
 				reason
 			});
 			await modlogEnry.save();
 		} catch (e) {
-			this.client.console.error(`BanCommand`, `Error saving to database. ${e?.stack}`);
+			this.client.console.error(`KickCommand`, `Error saving to database. ${e?.stack}`);
 			yield `${this.client.util.emojis.error} Error saving to database. Please report this to a developer.`;
 			return;
 		}
diff --git a/src/commands/moderation/modlog.ts b/src/commands/moderation/modlog.ts
index 862a26d..e32df42 100644
--- a/src/commands/moderation/modlog.ts
+++ b/src/commands/moderation/modlog.ts
@@ -3,7 +3,7 @@ import { Argument } from 'discord-akairo';
 import { Message, MessageEmbed } from 'discord.js';
 import moment from 'moment';
 import { BushCommand } from '../../lib/extensions/BushCommand';
-import { Modlog } from '../../lib/models';
+import { ModLog } from '../../lib/models';
 
 export default class ModlogCommand extends BushCommand {
 	constructor() {
@@ -35,7 +35,8 @@ export default class ModlogCommand extends BushCommand {
 			id: 'search',
 			type: Argument.union('user', 'string'),
 			prompt: {
-				start: 'What modlog id or user would you like to see?'
+				start: 'What modlog id or user would you like to see?',
+				retry: '{error} Choose a valid modlog id or user.'
 			}
 		};
 		if (typeof search === 'string') return { search, page: null };
@@ -45,7 +46,7 @@ export default class ModlogCommand extends BushCommand {
 				type: 'number',
 				prompt: {
 					start: 'What page?',
-					retry: 'Not a number. What page?',
+					retry: '{error} Choose a valid page to view.',
 					optional: true
 				}
 			};
@@ -55,7 +56,7 @@ export default class ModlogCommand extends BushCommand {
 	async exec(message: Message, { search, page }: { search: string; page: number }): Promise<void> {
 		const foundUser = await this.client.util.resolveUserAsync(search);
 		if (foundUser) {
-			const logs = await Modlog.findAll({
+			const logs = await ModLog.findAll({
 				where: {
 					guild: message.guild.id,
 					user: foundUser.id
@@ -65,24 +66,25 @@ export default class ModlogCommand extends BushCommand {
 			const niceLogs: string[] = [];
 			for (const log of logs) {
 				niceLogs.push(stripIndent`
-					ID: ${log.id}
-					Type: ${log.type.toLowerCase()}
-					User: <@!${log.user}> (${log.user})
-					Moderator: <@!${log.moderator}> (${log.moderator})
-					Duration: ${log.duration ? moment.duration(log.duration, 'milliseconds').humanize() : 'N/A'}
-					Reason: ${log.reason || 'None given'}
-					${this.client.util.ordinal(logs.indexOf(log) + 1)} action
+					**Case ID**: ${log.id}
+					**Type**: ${log.type.toLowerCase()}
+					**User**: <@!${log.user}> (${log.user})
+					**Moderator**: <@!${log.moderator}> (${log.moderator})
+					**Duration**: ${log.duration ? moment.duration(log.duration, 'milliseconds').humanize() : 'N/A'}
+					**Reason**: ${log.reason || 'None given'}
+					**${this.client.util.ordinal(logs.indexOf(log) + 1)}** action
 				`);
 			}
 			const chunked: string[][] = this.client.util.chunk(niceLogs, 3);
 			const embedPages = chunked.map(
 				(e, i) =>
 					new MessageEmbed({
-						title: `Modlogs page ${i + 1}`,
-						description: e.join('\n-------------------------------------------------------\n'),
+						title: foundUser.tag,
+						description: e.join('\n**---------------------------**\n'),
 						footer: {
 							text: `Page ${i + 1}/${chunked.length}`
-						}
+						},
+						color: this.client.util.colors.default
 					})
 			);
 			if (page) {
@@ -93,15 +95,15 @@ export default class ModlogCommand extends BushCommand {
 				return;
 			}
 		} else if (search) {
-			const entry = await Modlog.findByPk(search);
+			const entry = await ModLog.findByPk(search);
 			if (!entry) {
-				await message.util.send('That modlog does not exist.');
+				await message.util.send(`${this.client.util.emojis.error} That modlog does not exist.`);
 				return;
 			}
 			await message.util.send({
 				embeds: [
 					new MessageEmbed({
-						title: `Modlog ${entry.id}`,
+						title: `${entry.id}`,
 						fields: [
 							{
 								name: 'Type',
diff --git a/src/commands/moderation/mute.ts b/src/commands/moderation/mute.ts
new file mode 100644
index 0000000..9b6ad70
--- /dev/null
+++ b/src/commands/moderation/mute.ts
@@ -0,0 +1,166 @@
+import { Argument } from 'discord-akairo';
+import { CommandInteraction, Message, User } from 'discord.js';
+import moment from 'moment';
+import { BushCommand } from '../../lib/extensions/BushCommand';
+import { Guild, ModLog, ModLogType, Mute } from '../../lib/models';
+
+export default class MuteCommand extends BushCommand {
+	constructor() {
+		super('mute', {
+			aliases: ['mute'],
+			category: 'moderation',
+			args: [
+				{
+					id: 'user',
+					type: 'user',
+					prompt: {
+						start: 'What user would you like to mute?',
+						retry: '{error} Choose a valid user to mute.'
+					}
+				},
+				{
+					id: 'reason',
+					match: 'separate',
+					prompt: {
+						start: 'Why would you like to mute this user?',
+						retry: '{error} Choose a mute reason.',
+						optional: true
+					}
+				},
+				{
+					id: 'time',
+					type: 'duration',
+					match: 'option',
+					flag: '--time'
+				}
+			],
+			clientPermissions: ['MANAGE_ROLES'],
+			userPermissions: ['MANAGE_MESSAGES'],
+			description: {
+				content: 'Mute a user.',
+				usage: 'mute <member> <reason> [--time]',
+				examples: ['mute @user bad boi --time 1h']
+			},
+			slashOptions: [
+				{
+					type: 'USER',
+					name: 'user',
+					description: 'The user to mute.',
+					required: true
+				},
+				{
+					type: 'STRING',
+					name: 'reason',
+					description: 'Why the user is getting muted.',
+					required: false
+				},
+				{
+					type: 'STRING',
+					name: 'time',
+					description: 'How long the user should be muted for.',
+					required: false
+				}
+			],
+			slash: true
+		});
+	}
+	async *genResponses(
+		message: Message | CommandInteraction,
+		user: User,
+		reason?: string,
+		time?: number
+	): AsyncIterable<string> {
+		const duration = moment.duration(time);
+		let modlogEnry: ModLog;
+		let muteEntry: Mute;
+		// Create guild entry so postgres doesn't get mad when I try and add a modlog entry
+		await Guild.findOrCreate({
+			where: {
+				id: message.guild.id
+			},
+			defaults: {
+				id: message.guild.id
+			}
+		});
+		try {
+			const muteRole = (await Guild.findByPk(message.guild.id)).get('muteRole');
+			try {
+				if (time) {
+					modlogEnry = ModLog.build({
+						user: user.id,
+						guild: message.guild.id,
+						reason,
+						type: ModLogType.TEMP_MUTE,
+						duration: duration.asMilliseconds(),
+						moderator: message instanceof CommandInteraction ? message.user.id : message.author.id
+					});
+					muteEntry = Mute.build({
+						user: user.id,
+						guild: message.guild.id,
+						reason,
+						expires: new Date(new Date().getTime() + duration.asMilliseconds()),
+						modlog: modlogEnry.id
+					});
+				} else {
+					modlogEnry = ModLog.build({
+						user: user.id,
+						guild: message.guild.id,
+						reason,
+						type: ModLogType.MUTE,
+						moderator: message instanceof CommandInteraction ? message.user.id : message.author.id
+					});
+					muteEntry = Mute.build({
+						user: user.id,
+						guild: message.guild.id,
+						reason,
+						modlog: modlogEnry.id
+					});
+				}
+				await modlogEnry.save();
+				await muteEntry.save();
+			} catch (e) {
+				this.client.console.error(`MuteCommand`, `Error saving to database. ${e?.stack}`);
+				yield `${this.client.util.emojis.error} Error saving to database. Please report this to a developer.`;
+				return;
+			}
+			try {
+				await user.send(
+					`You were muted in ${message.guild.name} ${time ? `for ${duration.humanize()}` : 'permanently'} with reason \`${
+						reason || 'No reason given'
+					}\``
+				);
+			} catch (e) {
+				yield `${this.client.util.emojis.warn} Unable to dm user`;
+			}
+			await (
+				await message.guild.members.fetch(user)
+			).roles.add(
+				muteRole,
+				`Muted by ${message instanceof CommandInteraction ? message.user.tag : message.author.tag} with ${
+					reason ? `reason ${reason}` : 'no reason'
+				}`
+			);
+			yield `${this.client.util.emojis.success} muted <@!${user.id}> ${
+				time ? `for ${duration.humanize()}` : 'permanently'
+			} with reason \`${reason || 'No reason given'}\``;
+		} catch {
+			yield `${this.client.util.emojis.error} Error muting :/`;
+			await muteEntry.destroy();
+			await modlogEnry.destroy();
+			return;
+		}
+	}
+	async exec(
+		message: Message,
+		{ user, reason, time }: { user: User; reason?: string[]; time?: string | number }
+	): Promise<void> {
+		this.client.console.debug(reason);
+
+		if (typeof time === 'string') {
+			time = (await Argument.cast('duration', this.client.commandHandler.resolver, message, time)) as number;
+		}
+		for await (const response of this.genResponses(message, user, reason.join(' '), time)) {
+			await message.util.sendNew(response);
+		}
+	}
+}
diff --git a/src/commands/moderation/unban.ts b/src/commands/moderation/unban.ts
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/commands/moderation/unban.ts
diff --git a/src/commands/moderation/unblock.ts b/src/commands/moderation/unblock.ts
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/commands/moderation/unblock.ts
diff --git a/src/commands/moderation/unmute.ts b/src/commands/moderation/unmute.ts
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/commands/moderation/unmute.ts
diff --git a/src/commands/moderation/warn.ts b/src/commands/moderation/warn.ts
index 3410d81..d48049b 100644
--- a/src/commands/moderation/warn.ts
+++ b/src/commands/moderation/warn.ts
@@ -1,6 +1,6 @@
 import { GuildMember, Message } from 'discord.js';
 import { BushCommand } from '../../lib/extensions/BushCommand';
-import { Guild, Modlog, ModlogType } from '../../lib/models';
+import { Guild, ModLog, ModLogType } from '../../lib/models';
 
 export default class WarnCommand extends BushCommand {
 	public constructor() {
@@ -36,11 +36,11 @@ export default class WarnCommand extends BushCommand {
 			}
 		});
 		try {
-			const entry = Modlog.build({
+			const entry = ModLog.build({
 				user: member.id,
 				guild: message.guild.id,
 				moderator: message.author.id,
-				type: ModlogType.WARN,
+				type: ModLogType.WARN,
 				reason
 			});
 			await entry.save();
diff --git a/src/commands/moulberry-bush/capePerms.ts b/src/commands/moulberry-bush/capePerms.ts
index 3e4563a..d1850c8 100644
--- a/src/commands/moulberry-bush/capePerms.ts
+++ b/src/commands/moulberry-bush/capePerms.ts
@@ -1,17 +1,8 @@
-import { Message, MessageEmbed } from 'discord.js';
+import { Constants } from 'discord-akairo';
+import { MessageEmbed } from 'discord.js';
 import got from 'got';
-import { SlashCommandOption } from '../../lib/extensions/BushClientUtil';
 import { BushCommand } from '../../lib/extensions/BushCommand';
-import { BushSlashMessage } from '../../lib/extensions/BushInteractionMessage';
-
-interface Capeperms {
-	success: boolean;
-	perms: User[];
-}
-interface User {
-	_id: string;
-	perms: string[];
-}
+import { BushMessage } from '../../lib/extensions/BushMessage';
 
 export default class CapePermissionsCommand extends BushCommand {
 	private nameMap = {
@@ -19,31 +10,32 @@ export default class CapePermissionsCommand extends BushCommand {
 		patreon2: 'Patreon Tier 2',
 		fade: 'Fade',
 		contrib: 'Contributor',
-		nullzee: 'Nullzee',
-		gravy: 'ThatGravyBoat',
-		space: 'Space',
-		mcworld: 'Minecraft World',
-		lava: 'Lava',
-		packshq: 'PacksHQ',
-		mbstaff: "Moulberry's Bush staff",
-		thebakery: "Biscuit's Bakery",
-		negative: 'Negative',
-		void: 'Void',
-		ironmoon: 'IRONM00N',
-		krusty: 'Krusty',
-		furf: 'FurfSky Reborn',
-		soldier: 'Soldier',
-		dsm: "Danker's Skyblock Mod",
-		zera: 'Zera',
-		tunnel: 'Tunnel',
-		alexxoffi: 'Alexxoffi',
-		parallax: 'Parallax',
-		jakethybro: 'Jakethybro',
-		planets: 'Planets'
+		nullzee: 'Patreon Tier 1',
+		gravy: 'Patreon Tier 1',
+		space: 'Patreon Tier 1',
+		mcworld: 'Patreon Tier 1',
+		lava: 'Patreon Tier 1',
+		packshq: 'Patreon Tier 1',
+		mbstaff: 'Patreon Tier 1',
+		thebakery: 'Patreon Tier 1',
+		negative: 'Patreon Tier 1',
+		void: 'Patreon Tier 1',
+		ironmoon: 'Patreon Tier 1',
+		krusty: 'Patreon Tier 1',
+		furf: 'Patreon Tier 1',
+		soldier: 'Patreon Tier 1',
+		dsm: 'Patreon Tier 1',
+		zera: 'Patreon Tier 1',
+		tunnel: 'Patreon Tier 1',
+		alexxoffi: 'Patreon Tier 1',
+		parallax: 'Patreon Tier 1',
+		jakethybro: 'Patreon Tier 1',
+		planets: 'Patreon Tier 1'
 	};
+
 	public constructor() {
-		super('capeperms', {
-			aliases: ['capeperms', 'capeperm', 'capepermissions', 'capepermission'],
+		super('capepermissions', {
+			aliases: ['capeperms', 'capeperm', 'capepermissions'],
 			category: "Moulberry's Bush",
 			description: {
 				content: 'A command to see what capes someone has access to.',
@@ -52,8 +44,9 @@ export default class CapePermissionsCommand extends BushCommand {
 			},
 			args: [
 				{
-					id: 'user',
-					type: 'string',
+					id: 'ign',
+					type: Constants.ArgumentTypes.STRING,
+					match: Constants.ArgumentMatches.PHRASE,
 					prompt: {
 						start: 'Who would you like to see the cape permissions of?',
 						retry: '{error} Choose someone to see the capes their available capes.',
@@ -63,53 +56,72 @@ export default class CapePermissionsCommand extends BushCommand {
 			],
 			clientPermissions: ['EMBED_LINKS', 'SEND_MESSAGES'],
 			channel: 'guild',
+			slash: true,
 			slashOptions: [
 				{
+					name: 'ign',
+					description: 'The ign of the player you would like to view the capes permissions of.',
 					type: 'STRING',
-					name: 'user',
-					description: 'The username of the player to see the cape permissions of',
 					required: true
 				}
-			],
-			slash: true
+			]
 		});
 	}
-	private async getResponse(user: string): Promise<{ content?: string; embeds?: MessageEmbed[] }> {
+
+	public async exec(message: BushMessage, args: { ign: string }): Promise<unknown> {
+		interface Capeperms {
+			success: boolean;
+			perms: User[];
+		}
+
+		interface User {
+			_id: string;
+			perms: string[];
+		}
+
 		let capeperms: Capeperms, uuid: string;
 		try {
-			uuid = await this.client.util.mcUUID(user);
+			uuid = await this.client.util.mcUUID(args.ign);
 		} catch (e) {
-			return { content: `${this.client.util.emojis.error} \`${user}\` doesn't appear to be a valid username.` };
+			return await message.util.reply(
+				`${this.client.util.emojis.error} \`${args.ign}\` doesn't appear to be a valid username.`
+			);
 		}
 
 		try {
-			capeperms = await got.get('http://moulberry.codes/permscapes.json').json();
+			capeperms = await got.get('https://moulberry.codes/permscapes.json').json();
 		} catch (error) {
 			capeperms = null;
 		}
 		if (capeperms == null) {
-			return { content: `${this.client.util.emojis.error} There was an error finding cape perms for \`${user}\`.` };
+			return await message.util.reply(
+				`${this.client.util.emojis.error} There was an error finding cape perms for \`${args.ign}\`.`
+			);
 		} else {
 			if (capeperms?.perms) {
-				const foundUser = capeperms.perms.find((u) => u._id === uuid);
-				if (foundUser == null)
-					return { content: `${this.client.util.emojis.error} \`${user}\` does not appear to have any capes.` };
-				const userPerm: string[] = foundUser.perms;
-				const embed = this.client.util
-					.createEmbed(this.client.util.colors.default)
-					.setTitle(`${user}'s Capes`)
-					.setDescription(userPerm.join('\n'));
-				return { embeds: [embed] };
+				let index = null;
+
+				for (let i = 0; i < capeperms.perms.length; i++) {
+					if (capeperms.perms[i]._id == uuid) {
+						index = i;
+						break;
+					}
+				}
+				if (index == null)
+					return await message.util.reply(
+						`${this.client.util.emojis.error} \`${args.ign}\` does not appear to have any capes.`
+					);
+				const userPerm: string[] = capeperms.perms[index].perms;
+				const embed = new MessageEmbed()
+					.setTitle(`${args.ign}'s Capes`)
+					.setDescription(userPerm.join('\n'))
+					.setColor(this.client.util.colors.default);
+				await message.util.reply({ embeds: [embed] });
 			} else {
-				return { content: `${this.client.util.emojis.error} There was an error finding cape perms for ${user}.` };
+				return await message.util.reply(
+					`${this.client.util.emojis.error} There was an error finding cape perms for ${args.ign}.`
+				);
 			}
 		}
 	}
-	public async exec(message: Message, { user }: { user: string }): Promise<void> {
-		await message.reply(await this.getResponse(user));
-	}
-
-	public async execSlash(message: BushSlashMessage, { user }: { user: SlashCommandOption<string> }): Promise<void> {
-		await message.reply(await this.getResponse(user.value));
-	}
 }
diff --git a/src/commands/moulberry-bush/giveawayPing.ts b/src/commands/moulberry-bush/giveawayPing.ts
index d308602..19163d7 100644
--- a/src/commands/moulberry-bush/giveawayPing.ts
+++ b/src/commands/moulberry-bush/giveawayPing.ts
@@ -1,5 +1,5 @@
-import { Message, NewsChannel, TextChannel, WebhookClient } from 'discord.js';
 import { BushCommand } from '../../lib/extensions/BushCommand';
+import { BushMessage } from '../../lib/extensions/BushMessage';
 import AllowedMentions from '../../lib/utils/AllowedMentions';
 
 export default class GiveawayPingCommand extends BushCommand {
@@ -19,16 +19,26 @@ export default class GiveawayPingCommand extends BushCommand {
 			ignorePermissions: [],
 			cooldown: 1.44e7, //4 hours
 			ratelimit: 1,
-			editable: false
+			editable: false,
+			restrictedGuilds: ['516977525906341928'],
+			restrictedChannels: ['767782084981817344', '833855738501267456']
 		});
 	}
-	public async exec(message: Message): Promise<unknown> {
-		if (message.guild.id !== '516977525906341928')
-			return message.reply(`${this.client.util.emojis.error} This command may only be run in Moulberry's Bush.`);
-		if (!['767782084981817344', '833855738501267456'].includes(message.channel.id))
-			return message.reply(`${this.client.util.emojis.error} This command may only be run in giveaway channels.`);
-		await message.delete().catch(() => undefined);
-		const webhooks = await (message.channel as TextChannel | NewsChannel).fetchWebhooks();
+
+	public async exec(message: BushMessage): Promise<unknown> {
+		if (!message.member.permissions.has('MANAGE_GUILD'))
+			await message.util.reply(`${this.client.util.emojis.error} You are missing the \`manage server\` permission.`);
+
+		await message.delete().catch(() => {});
+
+		return await message.channel.send({
+			content:
+				'🎉 <@&767782793261875210> Giveaway.\n\n<:mad:783046135392239626> Spamming, line breaking, gibberish etc. disqualifies you from winning. We can and will ban you from giveaways. Winners will all be checked and rerolled if needed.',
+			allowedMentions: AllowedMentions.roles()
+		});
+
+		//! Broken
+		/* const webhooks = await (message.channel as TextChannel | NewsChannel).fetchWebhooks();
 		let webhookClient: WebhookClient;
 		if (webhooks.size < 1) {
 			const webhook = await (message.channel as TextChannel | NewsChannel).createWebhook('Giveaway ping webhook');
@@ -37,11 +47,12 @@ export default class GiveawayPingCommand extends BushCommand {
 			const webhook = webhooks.first();
 			webhookClient = new WebhookClient(webhook.id, webhook.token);
 		}
-		return webhookClient.send({
-			content: `🎉 <@&767782793261875210> Giveaway.\n\n${this.client.util.emojis.mad} Spamming, line breaking, gibberish etc. disqualifies you from winning. We can and will ban you from giveaways. Winners will all be checked and rerolled if needed.`,
+		return await webhookClient.send({
+			content:
+				'🎉 <@&767782793261875210> Giveaway.\n\n<:mad:783046135392239626> Spamming, line breaking, gibberish etc. disqualifies you from winning. We can and will ban you from giveaways. Winners will all be checked and rerolled if needed.',
 			username: `${message.member.nickname || message.author.username}`,
 			avatarURL: message.author.avatarURL({ dynamic: true }),
 			allowedMentions: AllowedMentions.roles()
-		});
+		}); */
 	}
 }
diff --git a/src/commands/moulberry-bush/level.ts b/src/commands/moulberry-bush/level.ts
index f822555..41541e0 100644
--- a/src/commands/moulberry-bush/level.ts
+++ b/src/commands/moulberry-bush/level.ts
@@ -1,4 +1,4 @@
-import { CommandInteractionOption, Message, User } from 'discord.js';
+import { Message, User } from 'discord.js';
 import { BushCommand } from '../../lib/extensions/BushCommand';
 import { BushSlashMessage } from '../../lib/extensions/BushInteractionMessage';
 import { Level } from '../../lib/models';
@@ -26,7 +26,7 @@ export default class LevelCommand extends BushCommand {
 					type: 'user',
 					prompt: {
 						start: 'What user would you like to see the level of?',
-						retry: 'Invalid user. What user would you like to see the level of?',
+						retry: '{error} Choose a valid user to see the level of.',
 						optional: true
 					}
 				}
@@ -139,7 +139,7 @@ export default class LevelCommand extends BushCommand {
 		}
 	}
 
-	async exec(message: Message, { user }: { user?: User }): Promise<void> {
+	async exec(message: Message | BushSlashMessage, { user }: { user?: User }): Promise<void> {
 		// await message.reply(
 		// 	new MessageAttachment(
 		// 		await this.getImage(user || message.author),
@@ -148,13 +148,4 @@ export default class LevelCommand extends BushCommand {
 		// );
 		await message.reply(await this.getResponse(user || message.author));
 	}
-	async execSlash(message: BushSlashMessage, { user }: { user?: CommandInteractionOption }): Promise<void> {
-		// await message.reply(
-		// 	new MessageAttachment(
-		// 		await this.getImage(user?.user || message.user),
-		// 		'lel.png'
-		// 	)
-		// );
-		await message.reply(await this.getResponse(user?.user || message.author));
-	}
 }
diff --git a/src/commands/moulberry-bush/rule.ts b/src/commands/moulberry-bush/rule.ts
index e9b09eb..3cd9ec6 100644
--- a/src/commands/moulberry-bush/rule.ts
+++ b/src/commands/moulberry-bush/rule.ts
@@ -1,69 +1,60 @@
-import { Argument } from 'discord-akairo';
-import { CommandInteraction, Message, MessageEmbed, User } from 'discord.js';
-import { SlashCommandOption } from '../../lib/extensions/BushClientUtil';
+import { Argument, Constants } from 'discord-akairo';
+import { MessageEmbed, User } from 'discord.js';
 import { BushCommand } from '../../lib/extensions/BushCommand';
-import { BushSlashMessage } from '../../lib/extensions/BushInteractionMessage';
+import { BushMessage } from '../../lib/extensions/BushMessage';
+import AllowedMentions from '../../lib/utils/AllowedMentions';
 
+const rules = [
+	{
+		title: "1.) Follow Discord's TOS",
+		description:
+			"Be sure to follow discord's TOS found at <https://discordapp.com/tos>, you must be 13 to use discord so if you admit to being under 13 you will be banned from the server."
+	},
+	{
+		title: '2.) Be Respectful',
+		description:
+			'Racist, sexist, homophobic, xenophobic, transphobic, ableist, hate speech, slurs, or any other derogatory, toxic, or discriminatory behavior will not be tolerated.'
+	},
+	{
+		title: '3.) No Spamming',
+		description:
+			'Including but not limited to: any messages that do not contribute to the conversation, repeated messages, randomly tagging users, and chat flood.'
+	},
+	{
+		title: '4.) English',
+		description: 'The primary language of the server is English, please keep all discussions in English.'
+	},
+	{
+		title: '5.) Safe for Work',
+		description:
+			'Please keep NSFW and NSFL content out of this server, avoid borderline images as well as keeping your status, profile picture, and banner SFW.'
+	},
+	{
+		title: '6.) No Advertising',
+		description: 'Do not promote anything without prior approval from a staff member, this includes DM advertising.'
+	},
+	{
+		title: '7.) Impersonation',
+		description:
+			'Do not try to impersonate others for the express intent of being deceitful, defamation , and/or personal gain.'
+	},
+	{ title: '8.) Swearing', description: 'Swearing is allowed only when not used as an insult.' },
+	{
+		title: "9.) Sending media that are able to crash a user's Discord",
+		description:
+			"Sending videos, GIFs, emojis, etc. that are able to crash someone's discord will result in a **permanent** ban that cannot be appealed."
+	},
+	{
+		title: '10.) No Backseat Moderating',
+		description: 'If you see a rule being broken be broken, please report it using: `-report <user> [evidence]`.'
+	},
+	{
+		title: '11.) Staff may moderate at their discretion',
+		description:
+			'If there are loopholes in our rules, the staff team may moderate based on what they deem appropriate. The staff team holds final discretion.'
+	}
+];
 export default class RuleCommand extends BushCommand {
-	private rules = [
-		{
-			title: "Follow Discord's TOS",
-			description:
-				"Be sure to follow discord's TOS found at <https://discordapp.com/tos>, you must be 13 to use discord so if you admit to being under 13 you will be banned from the server."
-		},
-		{
-			title: 'Be Respectful',
-			description:
-				'Racist, sexist, homophobic, xenophobic, transphobic, ableist, hate speech, slurs, or any other derogatory, toxic, or discriminatory behavior will not be tolerated.'
-		},
-		{
-			title: 'No Spamming',
-			description:
-				'Including but not limited to: any messages that do not contribute to the conversation, repeated messages, randomly tagging users, and chat flood.'
-		},
-		{
-			title: 'English',
-			description: 'The primary language of the server is English, please keep all discussions in English.'
-		},
-		{
-			title: 'Safe for Work',
-			description:
-				'Please keep NSFW and NSFL content out of this server, avoid borderline images as well as keeping your status and profile picture SFW.'
-		},
-		{
-			title: 'No Advertising',
-			description: 'Do not promote anything without prior approval from a staff member, this includes DM advertising.'
-		},
-		{
-			title: 'Impersonation',
-			description:
-				'Do not try to impersonate others for the express intent of being deceitful, defamation , and/or personal gain.'
-		},
-		{
-			title: 'Swearing',
-			description: 'Swearing is allowed only when not used as an insult.'
-		},
-		{
-			title: 'Only ping @emergency in emergencies',
-			description:
-				'Pinging <@&833802660209229854> for no reason will result in severe punishment.  <@&833802660209229854> is only to be pinged in true emergencies.'
-		},
-		{
-			title: 'No Backseat Moderating',
-			description: 'If you see a rule being broken be broken, please report it using: `-report <user> [evidence]`.'
-		},
-		{
-			title: 'Staff may moderate at their discretion',
-			description:
-				'If there are loopholes in our rules, the staff team may moderate based on what they deem appropriate. The staff team holds final discretion.'
-		},
-		{
-			title: "Sending media that are able to crash a user's Discord",
-			description:
-				"Sending videos, GIFs, emojis, etc. that are able to crash someone's discord will result in a **permanent** mute that cannot be appealed."
-		}
-	];
-
 	public constructor() {
 		super('rule', {
 			aliases: ['rule', 'rules'],
@@ -76,98 +67,93 @@ export default class RuleCommand extends BushCommand {
 			args: [
 				{
 					id: 'rule',
-					type: Argument.range('number', 1, 12, true),
+					type: Argument.range(Constants.ArgumentTypes.INTEGER, 1, rules.length, true),
+					match: Constants.ArgumentMatches.PHRASE,
 					prompt: {
 						start: 'What rule would you like to have cited?',
 						retry: '{error} Choose a valid rule.',
 						optional: true
-					},
-					default: undefined
+					}
 				},
 				{
 					id: 'user',
 					type: 'user',
+					match: Constants.ArgumentMatches.PHRASE,
 					prompt: {
 						start: 'What user would you like to mention?',
 						retry: '{error} Choose a valid user to mention.',
 						optional: true
-					},
-					default: undefined
+					}
 				}
 			],
 			clientPermissions: ['EMBED_LINKS', 'SEND_MESSAGES'],
 			channel: 'guild',
+			restrictedGuilds: ['516977525906341928'],
+			slash: true,
 			slashOptions: [
 				{
-					type: 'INTEGER',
 					name: 'rule',
-					description: 'The rule to show',
+					description: 'The rule you would you like to have cited',
+					type: 'INTEGER',
 					required: false
 				},
 				{
-					type: 'USER',
 					name: 'user',
-					description: 'The user to ping',
+					description: 'The user you would like to mention.',
+					type: 'USER',
 					required: false
 				}
 			],
-			slash: true
+			slashGuilds: ['516977525906341928']
 		});
 	}
-	private getResponse(
-		message: Message | CommandInteraction,
-		rule?: number,
-		user?: User
-	): { content?: string; embeds?: MessageEmbed[] } | [string, MessageEmbed] {
-		if (
-			message.guild.id !== '516977525906341928' &&
-			!this.client.ownerID.includes(message instanceof Message ? message.author.id : message.user.id)
-		) {
-			return { content: `${this.client.util.emojis.error} This command can only be run in Moulberry's Bush.` };
-		}
-		let rulesEmbed = new MessageEmbed().setColor('ef3929');
-		if (message instanceof Message) {
-			rulesEmbed = rulesEmbed.setFooter(`Triggered by ${message.author.tag}`, message.author.avatarURL({ dynamic: true }));
+
+	public async exec(message: BushMessage, { rule, user }: { rule: undefined | number; user: User }): Promise<unknown> {
+		const rulesEmbed = new MessageEmbed()
+			.setColor('ef3929')
+			.setFooter(`Triggered by ${message.author.tag}`, message.author.avatarURL({ dynamic: true }))
+			.setTimestamp();
+
+		if (rule > 12 || rule < 1) {
+			rule = undefined;
 		}
 		if (rule) {
-			const foundRule = this.rules[rule - 1];
-			rulesEmbed.addField(`${rule}) ${foundRule.title}`, foundRule.description);
+			if (rules[rule - 1]?.title && rules[rule - 1]?.description)
+				rulesEmbed.addField(rules[rule - 1].title, rules[rule - 1].description);
 		} else {
-			for (const curRule of this.rules) {
-				rulesEmbed.addField(`${this.rules.indexOf(curRule) + 1}) ${curRule.title}`, curRule.description);
+			for (let i = 0; i < rules.length; i++) {
+				if (rules[i]?.title && rules[i]?.description) rulesEmbed.addField(rules[i].title, rules[i].description);
 			}
 		}
-		if (!user) {
-			return { embeds: [rulesEmbed] };
-		} else {
-			return [`<@!${user.id}>`, rulesEmbed];
-		}
-	}
-	public async exec(message: Message, { rule, user }: { rule?: number; user?: User }): Promise<void> {
-		const response = this.getResponse(message, rule, user);
-		if (Array.isArray(response)) {
-			await message.util.send({
-				content: response[0],
-				embeds: [response[1]]
-			});
-		} else {
-			await message.util.send(response);
+		await respond();
+		if (!message.util.isSlash) {
+			await message.delete().catch(() => {});
 		}
-		await message.delete().catch(() => undefined);
-	}
-
-	public async execSlash(
-		message: BushSlashMessage,
-		{ rule, user }: { rule?: SlashCommandOption<number>; user?: SlashCommandOption<void> }
-	): Promise<void> {
-		const response = this.getResponse(message.interaction, rule?.value, user?.user);
-		if (Array.isArray(response)) {
-			await message.interaction.reply({
-				content: response[0],
-				embeds: [response[1]]
-			});
-		} else {
-			await message.interaction.reply(response);
+		return;
+		async function respond(): Promise<unknown> {
+			if (!user) {
+				return (
+					// If the original message was a reply -> imitate it
+					message.reference?.messageID && !message.util.isSlash
+						? await message.channel.messages.fetch(message.reference.messageID).then(async (message) => {
+								await message.util.reply({ embeds: [rulesEmbed], allowedMentions: AllowedMentions.users() });
+						  })
+						: await message.util.send({ embeds: [rulesEmbed], allowedMentions: AllowedMentions.users() })
+				);
+			} else {
+				return message.reference?.messageID && !message.util.isSlash
+					? await message.util.send({
+							content: `<@!${user.id}>`,
+							embeds: [rulesEmbed],
+							allowedMentions: AllowedMentions.users(),
+							reply: { messageReference: message.reference.messageID }
+					  })
+					: await message.util.send({
+							content: `<@!${user.id}>`,
+							embeds: [rulesEmbed],
+							allowedMentions: AllowedMentions.users()
+					  });
+			}
 		}
 	}
 }