From 401c43424fdf99d76918e19a232d04ea2d2434b5 Mon Sep 17 00:00:00 2001
From: ILike2WatchMemes <ilike2watchmemes@gmail.com>
Date: Sun, 9 Mar 2025 23:30:44 +0100
Subject: [PATCH 1/9] add slash commands

---
 .../skyhanni/discord/CommandListener.kt       | 116 +++++++++-
 .../hannibal2/skyhanni/discord/DiscordBot.kt  |  23 +-
 .../at/hannibal2/skyhanni/discord/Utils.kt    |  99 +++++++--
 .../skyhanni/discord/command/BaseCommand.kt   |   7 +-
 .../skyhanni/discord/command/HelpCommand.kt   |  84 ++++---
 .../discord/command/PullRequestCommand.kt     | 206 +++++++++---------
 .../discord/command/ServerCommands.kt         |  77 ++++---
 .../skyhanni/discord/command/TagCommands.kt   | 198 ++++++++++-------
 8 files changed, 539 insertions(+), 271 deletions(-)

diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt
index 92210f3..f2b43a1 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt
@@ -4,8 +4,18 @@ import at.hannibal2.skyhanni.discord.Utils.hasAdminPermissions
 import at.hannibal2.skyhanni.discord.Utils.inBotCommandChannel
 import at.hannibal2.skyhanni.discord.Utils.logAction
 import at.hannibal2.skyhanni.discord.Utils.reply
-import at.hannibal2.skyhanni.discord.command.*
+import at.hannibal2.skyhanni.discord.command.BaseCommand
+import at.hannibal2.skyhanni.discord.command.PullRequestCommand
+import at.hannibal2.skyhanni.discord.command.ServerCommands
+import at.hannibal2.skyhanni.discord.command.TagCommands
+import at.hannibal2.skyhanni.discord.command.HelpCommand
+import net.dv8tion.jda.api.entities.Guild
+import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
 import net.dv8tion.jda.api.events.message.MessageReceivedEvent
+import net.dv8tion.jda.api.interactions.commands.OptionType
+import net.dv8tion.jda.api.interactions.commands.build.Commands
+import net.dv8tion.jda.api.interactions.commands.build.SlashCommandData
 import org.reflections.Reflections
 import java.lang.reflect.Modifier
 
@@ -20,16 +30,25 @@ object CommandListener {
     fun init() {
         loadCommands()
         loadAliases()
+        BOT.jda.getGuildById(BOT.config.allowedServerId)?.let { createCommands(it) }
     }
 
     fun onMessage(bot: DiscordBot, event: MessageReceivedEvent) {
         event.onMessage(bot)
     }
 
+    fun onInteraction(bot: DiscordBot, event: SlashCommandInteractionEvent) {
+        event.onInteraction(bot)
+    }
+
+    fun onAutocomplete(event: CommandAutoCompleteInteractionEvent) {
+        event.onCompletion()
+    }
+
     private fun MessageReceivedEvent.onMessage(bot: DiscordBot) {
         val message = message.contentRaw.trim()
         if (!isFromGuild) {
-            logAction("private dm: '$message'")
+            logAction("private dm: '$message'", this)
             return
         }
         if (guild.id != bot.config.allowedServerId) return
@@ -59,35 +78,83 @@ object CommandListener {
         }
 
         if (!command.userCommand) {
-            if (!hasAdminPermissions()) {
-                reply("No permissions $PLEADING_FACE")
+            if (!hasAdminPermissions(this)) {
+                reply("No permissions $PLEADING_FACE", this)
                 return
             }
 
-            if (!inBotCommandChannel()) {
-                reply("Wrong channel $PLEADING_FACE")
+            if (!inBotCommandChannel(this)) {
+                reply("Wrong channel $PLEADING_FACE", this)
                 return
             }
         }
 
-        // allows to use `!<command> -help` instaed of `!help -<command>`
+        // allows to use `!<command> -help` instead of `!help -<command>`
         if (args.size == 1) {
             if (args.first() == "-help") {
                 with(HelpCommand) {
-                    this@onMessage.sendUsageReply(literal)
+                    this.sendUsageReply(literal, this@onMessage)
                 }
                 return
             }
         }
         try {
             with(command) {
-                this@onMessage.execute(args)
+                execute(args, this@onMessage)
+            }
+        } catch (e: Exception) {
+            reply("Error: ${e.message}", this)
+        }
+    }
+
+    private fun SlashCommandInteractionEvent.onInteraction(bot: DiscordBot) {
+        if (guild?.id != bot.config.allowedServerId || this.user.isBot) return
+
+        val command = getCommand(this.fullCommandName) ?: return
+
+        if (!command.userCommand) {
+            if (!hasAdminPermissions(this)) {
+                reply("No permissions $PLEADING_FACE")
+                return
+            }
+
+            if (!inBotCommandChannel(this)) {
+                reply("Wrong channel $PLEADING_FACE")
+                return
+            }
+        }
+
+        try {
+            with(command) {
+                execute(listOf(), this@onInteraction)
             }
         } catch (e: Exception) {
             reply("Error: ${e.message}")
         }
     }
 
+    private fun CommandAutoCompleteInteractionEvent.onCompletion() {
+        when (fullCommandName) {
+            "help" -> {
+                if (focusedOption.name != "command") return
+
+                replyChoiceStrings(
+                    commands.filterKeys { key -> key.startsWith(focusedOption.value) }.keys
+                ).queue()
+            }
+
+            "server" -> {
+                if (focusedOption.name != "keyword") return
+
+                replyChoiceStrings(
+                    ServerCommands.servers.filter { it.name.startsWith(focusedOption.value, true) }
+                        .map { it.name }
+                        .take(25)
+                ).queue()
+            }
+        }
+    }
+
     private val commandPattern = "^!(?!!).+".toPattern()
 
     // ensures the command starts with ! while ignoring !!
@@ -114,7 +181,6 @@ object CommandListener {
         }
     }
 
-
     private fun loadAliases() {
         for (command in commands.values) {
             for (alias in command.aliases) {
@@ -124,6 +190,34 @@ object CommandListener {
             }
         }
     }
+
+    fun createCommands(guild: Guild) {
+        guild.retrieveCommands().queue {
+            val commandData = commands.values.map { value -> convertToData(value) }
+
+            guild.updateCommands().addCommands(commandData).queue()
+        }
+    }
+
+    private fun convertToData(old: BaseCommand): SlashCommandData {
+        return Commands.slash(old.name, old.description).apply {
+            old.options.forEach { option ->
+                addOption(
+                    option.type,
+                    option.name.replace(" ", "_"),
+                    option.description,
+                    option.required,
+                    option.autoComplete
+                )
+            }
+        }
+    }
 }
 
-data class Option(val name: String, val description: String, val required: Boolean = true)
\ No newline at end of file
+open class Option(
+    val name: String,
+    val description: String,
+    val required: Boolean = true,
+    val type: OptionType = OptionType.STRING,
+    val autoComplete: Boolean = false
+)
\ No newline at end of file
diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/DiscordBot.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/DiscordBot.kt
index a243737..9a941f4 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/DiscordBot.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/DiscordBot.kt
@@ -3,7 +3,10 @@ package at.hannibal2.skyhanni.discord
 import at.hannibal2.skyhanni.discord.Utils.sendMessageToBotChannel
 import net.dv8tion.jda.api.JDA
 import net.dv8tion.jda.api.JDABuilder
+import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
 import net.dv8tion.jda.api.events.message.MessageReceivedEvent
+import net.dv8tion.jda.api.events.session.ReadyEvent
 import net.dv8tion.jda.api.hooks.ListenerAdapter
 import net.dv8tion.jda.api.requests.GatewayIntent
 import org.slf4j.Logger
@@ -68,12 +71,30 @@ private fun startBot(): DiscordBot {
     }.build()
 
     val bot = DiscordBot(jda, config)
-    jda.awaitReady()
     val messageListener = object : ListenerAdapter() {
         override fun onMessageReceived(event: MessageReceivedEvent) {
             CommandListener.onMessage(bot, event)
         }
     }
+    val slashCommandListener = object : ListenerAdapter() {
+        override fun onSlashCommandInteraction(event: SlashCommandInteractionEvent) {
+            CommandListener.onInteraction(bot, event)
+        }
+
+        override fun onCommandAutoCompleteInteraction(event: CommandAutoCompleteInteractionEvent) {
+            CommandListener.onAutocomplete(event)
+        }
+
+        override fun onReady(event: ReadyEvent) {
+            event.jda.getGuildById(config.allowedServerId)?.let {
+                CommandListener.createCommands(it)
+            }
+        }
+    }
+    jda.addEventListener(slashCommandListener)
     jda.addEventListener(messageListener)
+
+    jda.awaitReady()
+
     return bot
 }
diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/Utils.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/Utils.kt
index f92cf27..d928ae5 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/Utils.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/Utils.kt
@@ -1,14 +1,15 @@
 package at.hannibal2.skyhanni.discord
 
 import net.dv8tion.jda.api.EmbedBuilder
+import net.dv8tion.jda.api.entities.Member
 import net.dv8tion.jda.api.entities.Message
 import net.dv8tion.jda.api.entities.MessageEmbed
 import net.dv8tion.jda.api.entities.channel.concrete.TextChannel
 import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel
 import net.dv8tion.jda.api.entities.channel.unions.MessageChannelUnion
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
 import net.dv8tion.jda.api.events.message.MessageReceivedEvent
 import net.dv8tion.jda.api.utils.FileUpload
-import org.slf4j.LoggerFactory
 import java.awt.Color
 import java.io.File
 import java.util.zip.ZipFile
@@ -20,26 +21,43 @@ object Utils {
 
     private inline val logger get() = BOT.logger
 
-    fun MessageReceivedEvent.reply(text: String) {
-        message.messageReply(text)
+    fun reply(text: String, event: Any, ephemeral: Boolean = false) {
+        doWhen(event, {
+            it.message.messageReply(text)
+        }, {
+            it.reply(text).setEphemeral(ephemeral).queue()
+        })
     }
 
-    fun MessageReceivedEvent.userError(text: String) {
-        message.messageReply("❌ $text")
+    fun reply(embed: MessageEmbed, event: Any, ephemeral: Boolean = false) {
+        doWhen(event, {
+            it.message.messageReply(embed)
+        }, {
+            it.replyEmbeds(embed).setEphemeral(ephemeral).queue()
+        })
     }
 
-    fun MessageReceivedEvent.sendError(text: String) {
-        message.messageReply("❌ An error occurred: $text")
-        logAction("Error: $text")
+    fun userError(text: String, event: Any, ephemeral: Boolean = true) {
+        doWhen(event, {
+            it.message.messageReply("❌ $text")
+        }, {
+            it.reply("❌ $text").setEphemeral(ephemeral).queue()
+        })
     }
 
-    fun MessageReceivedEvent.reply(embed: MessageEmbed) {
-        message.messageReply(embed)
+    fun sendError(text: String, event: Any, ephemeral: Boolean = true) {
+        doWhen(event, {
+            it.message.messageReply("❌ $text")
+        }, {
+            it.reply("❌ $text").setEphemeral(ephemeral).queue()
+        })
+
+        logAction("Error: $text", event)
     }
 
     fun MessageReceivedEvent.replyWithConsumer(text: String, consumer: (MessageReceivedEvent) -> Unit) {
         BotMessageHandler.log(text, consumer)
-        reply(text)
+        reply(text, this)
     }
 
     fun Message.messageDelete() {
@@ -78,31 +96,68 @@ object Utils {
         BOT.jda.getTextChannelById(BOT.config.botCommandChannelId)?.messageSend(text)
     }
 
-    fun MessageReceivedEvent.logAction(action: String, raw: Boolean = false) {
+    fun logAction(action: String, event: Any, raw: Boolean = false) {
+        val author = when (event) {
+            is MessageReceivedEvent -> event.author
+            is SlashCommandInteractionEvent -> event.user
+            else -> throw IllegalArgumentException("Unknown event type")
+        }
+
+        val member = when (event) {
+            is MessageReceivedEvent -> event.member
+            is SlashCommandInteractionEvent -> event.member
+            else -> throw IllegalArgumentException("Unknown event type")
+        }
+
+        val channel = when (event) {
+            is MessageReceivedEvent -> event.channel
+            is SlashCommandInteractionEvent -> event.channel
+            else -> throw IllegalArgumentException("Unknown event type")
+        }
+
         if (raw) {
             logger.info(action)
             return
         }
+
         val name = author.name
         val id = author.id
+        val nickString = member?.nickname?.takeIf { it != "null" }?.let { " (`$it`)" } ?: ""
+        val isFromGuild =
+            (event as? MessageReceivedEvent)?.isFromGuild ?: (event as? SlashCommandInteractionEvent)?.isFromGuild
+            ?: false
+        val channelSuffix = if (isFromGuild) " in channel '${channel.name}'" else ""
 
-        val nick = member?.nickname?.takeIf { it != "null" }
-        val nickString = nick?.let { " (`$nick`)" } ?: ""
-
-        val channelSuffix = if (isFromGuild) {
-            val channelName = channel.name
-            " in channel '$channelName'"
-        } else ""
         logger.info("$id/$name$nickString $action$channelSuffix")
     }
 
-    fun MessageReceivedEvent.hasAdminPermissions(): Boolean {
-        val member = member ?: return false
+    fun hasAdminPermissions(event: Any): Boolean {
+        val member = doWhen(
+            event,
+            { it.member },
+            { it.member }
+        ) as Member
+
         val allowedRoleIds = BOT.config.editPermissionRoleIds.values
         return !member.roles.none { it.id in allowedRoleIds }
     }
 
-    fun MessageReceivedEvent.inBotCommandChannel() = channel.id == BOT.config.botCommandChannelId
+    fun <T> doWhen(
+        event: Any,
+        consumer: (MessageReceivedEvent) -> T?,
+        consumer2: (SlashCommandInteractionEvent) -> T?
+    ): T? {
+        return when (event) {
+            is MessageReceivedEvent -> consumer(event)
+            is SlashCommandInteractionEvent -> consumer2(event)
+            else -> null
+        }
+    }
+
+    fun inBotCommandChannel(event: Any): Boolean {
+        val id = doWhen(event, { it.channel.id }, { it.channel.id })
+        return id == BOT.config.botCommandChannelId
+    }
 
     fun runDelayed(duration: Duration, consumer: () -> Unit) {
         Thread {
diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/BaseCommand.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/BaseCommand.kt
index ff89aba..fbacf3d 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/BaseCommand.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/BaseCommand.kt
@@ -2,7 +2,6 @@ package at.hannibal2.skyhanni.discord.command
 
 import at.hannibal2.skyhanni.discord.Option
 import at.hannibal2.skyhanni.discord.Utils.userError
-import net.dv8tion.jda.api.events.message.MessageReceivedEvent
 
 abstract class BaseCommand {
 
@@ -16,9 +15,9 @@ abstract class BaseCommand {
 
     open val aliases: List<String> = emptyList()
 
-    abstract fun MessageReceivedEvent.execute(args: List<String>)
+    abstract fun execute(args: List<String>, event: Any)
 
-    protected fun MessageReceivedEvent.wrongUsage(args: String) {
-        userError("Usage: `!$name $args`")
+    protected fun wrongUsage(args: String, event: Any) {
+        userError("Usage: `!$name $args`", event)
     }
 }
\ No newline at end of file
diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/HelpCommand.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/HelpCommand.kt
index 95e0da0..661d1dc 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/HelpCommand.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/HelpCommand.kt
@@ -1,6 +1,10 @@
 package at.hannibal2.skyhanni.discord.command
 
-import at.hannibal2.skyhanni.discord.*
+import at.hannibal2.skyhanni.discord.BOT
+import at.hannibal2.skyhanni.discord.CommandListener
+import at.hannibal2.skyhanni.discord.Option
+import at.hannibal2.skyhanni.discord.PLEADING_FACE
+import at.hannibal2.skyhanni.discord.Utils.doWhen
 import at.hannibal2.skyhanni.discord.Utils.hasAdminPermissions
 import at.hannibal2.skyhanni.discord.Utils.inBotCommandChannel
 import at.hannibal2.skyhanni.discord.Utils.messageDelete
@@ -9,7 +13,6 @@ import at.hannibal2.skyhanni.discord.Utils.replyWithConsumer
 import at.hannibal2.skyhanni.discord.Utils.runDelayed
 import net.dv8tion.jda.api.EmbedBuilder
 import net.dv8tion.jda.api.entities.MessageEmbed
-import net.dv8tion.jda.api.events.message.MessageReceivedEvent
 import java.awt.Color
 import kotlin.time.Duration.Companion.seconds
 
@@ -17,68 +20,85 @@ object HelpCommand : BaseCommand() {
     override val name: String = "help"
     override val description: String = "Get help for all OR one specific command."
     override val options: List<Option> =
-        listOf(Option("command", "Command you want to get help for.", required = false))
+        listOf(Option("command", "Command you want to get help for.", required = false, autoComplete = true))
 
     override val userCommand: Boolean = true
 
-    override fun MessageReceivedEvent.execute(args: List<String>) {
+    override fun execute(args: List<String>, event: Any) {
         if (args.size > 1) {
-            reply("Usage: !help <command>")
+            reply("Usage: !help <command>", event)
             return
         }
 
-        if (args.size == 1) {
-            sendUsageReply(args.first().lowercase())
+        val command = doWhen(
+            event,
+            { if (args.isEmpty()) null else args.first().lowercase() },
+            { it.getOption("command")?.asString }
+        )
+
+        if (command != null) {
+            sendUsageReply(command, event)
         } else {
-            val commands = if (hasAdminPermissions() && inBotCommandChannel()) {
+            val commands = if (hasAdminPermissions(event) && inBotCommandChannel(event)) {
                 CommandListener.getCommands()
             } else {
                 CommandListener.getCommands().filter { it.userCommand }
             }
             val list = commands.joinToString(", !", prefix = "!") { it.name }
-            reply("Supported commands: $list")
+            reply("Supported commands: $list", event)
 
-            if (hasAdminPermissions() && !inBotCommandChannel()) {
+            if (hasAdminPermissions(event) && !inBotCommandChannel(event)) {
                 val id = BOT.config.botCommandChannelId
                 val botCommandChannel = "https://discord.com/channels/$id/$id"
-                replyWithConsumer("You wanna see the cool admin only commands? visit $botCommandChannel") { consumer ->
-                    runDelayed(3.seconds) {
-                        consumer.message.messageDelete()
+
+                doWhen(
+                    event, {
+                        it.replyWithConsumer("You wanna see the cool admin only commands? visit $botCommandChannel") { consumer ->
+                            runDelayed(3.seconds) {
+                                consumer.message.messageDelete()
+                            }
+                        }
+                    }, {
+                        it.channel.sendMessage("You wanna see the cool admin only commands? visit $botCommandChannel")
+                            .queue {
+                                runDelayed(3.seconds) {
+                                    it.channel.deleteMessageById(it.id).queue()
+                                }
+                            }
                     }
-                }
+                )
             }
         }
     }
 
 
-    fun MessageReceivedEvent.sendUsageReply(commandName: String) {
+    fun sendUsageReply(commandName: String, event: Any) {
         val command = CommandListener.getCommand(commandName) ?: run {
-            reply("Unknown command `!$commandName` $PLEADING_FACE")
+            reply("Unknown command `!$commandName` $PLEADING_FACE", event)
             return
         }
 
-        if (!command.userCommand && !hasAdminPermissions()) {
-            reply("No permissions for command `!$commandName` $PLEADING_FACE")
+        if (!command.userCommand && !hasAdminPermissions(event)) {
+            reply("No permissions for command `!$commandName` $PLEADING_FACE", event)
             return
         }
 
-        this.reply(command.createHelpEmbed(commandName))
+        reply(createHelpEmbed(commandName), event)
     }
+}
 
+fun BaseCommand.createHelpEmbed(commandName: String): MessageEmbed {
+    val em = EmbedBuilder()
 
-    private fun BaseCommand.createHelpEmbed(commandName: String): MessageEmbed {
-        val em = EmbedBuilder()
-
-        em.setTitle("Usage: /$commandName <" + this.options.joinToString("> <") { it.name } + ">")
-        em.setDescription("📋 **${this.description}**")
-        em.setColor(Color.GREEN)
+    em.setTitle("Usage: /$commandName <" + this.options.joinToString("> <") { it.name } + ">")
+    em.setDescription("📋 **${this.description}**")
+    em.setColor(Color.GREEN)
 
-        for (option in this.options) {
-            em.addField(option.name, option.description, true)
-            em.addField("Required", if (option.required) "✅" else "❌", true)
-            em.addBlankField(true)
-        }
-
-        return em.build()
+    for (option in this.options) {
+        em.addField(option.name, option.description, true)
+        em.addField("Required", if (option.required) "✅" else "❌", true)
+        em.addBlankField(true)
     }
+
+    return em.build()
 }
\ No newline at end of file
diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/PullRequestCommand.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/PullRequestCommand.kt
index 7697452..0fb83a4 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/PullRequestCommand.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/PullRequestCommand.kt
@@ -1,8 +1,12 @@
 package at.hannibal2.skyhanni.discord.command
 
-import at.hannibal2.skyhanni.discord.*
+import at.hannibal2.skyhanni.discord.BOT
+import at.hannibal2.skyhanni.discord.Option
+import at.hannibal2.skyhanni.discord.PLEADING_FACE
+import at.hannibal2.skyhanni.discord.SimpleTimeMark
 import at.hannibal2.skyhanni.discord.SimpleTimeMark.Companion.asTimeMark
 import at.hannibal2.skyhanni.discord.Utils.createParentDirIfNotExist
+import at.hannibal2.skyhanni.discord.Utils.doWhen
 import at.hannibal2.skyhanni.discord.Utils.embed
 import at.hannibal2.skyhanni.discord.Utils.format
 import at.hannibal2.skyhanni.discord.Utils.linkTo
@@ -12,11 +16,13 @@ import at.hannibal2.skyhanni.discord.Utils.reply
 import at.hannibal2.skyhanni.discord.Utils.replyWithConsumer
 import at.hannibal2.skyhanni.discord.Utils.runDelayed
 import at.hannibal2.skyhanni.discord.Utils.timeExecution
+import at.hannibal2.skyhanni.discord.Utils.unzipFile
 import at.hannibal2.skyhanni.discord.Utils.uploadFile
 import at.hannibal2.skyhanni.discord.Utils.userError
 import at.hannibal2.skyhanni.discord.github.GitHubClient
 import at.hannibal2.skyhanni.discord.json.discord.PullRequestJson
 import at.hannibal2.skyhanni.discord.json.discord.Status
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
 import net.dv8tion.jda.api.events.message.MessageReceivedEvent
 import java.awt.Color
 import java.io.File
@@ -44,112 +50,97 @@ object PullRequestCommand : BaseCommand() {
     private val runIdRegex =
         Regex("https://github\\.com/[\\w.]+/[\\w.]+/actions/runs/(?<RunId>\\d+)/job/(?<JobId>\\d+)")
 
-    override fun MessageReceivedEvent.execute(args: List<String>) {
-        if (args.size != 1) {
-            wrongUsage("<number>")
-            return
-        }
-        val first = args.first()
-        val prNumber = first.toIntOrNull() ?: run {
-            userError("Unknown number $PLEADING_FACE ($first})")
-            return
-        }
+    override fun execute(args: List<String>, event: Any) {
+        val prNumber = doWhen(event, {
+            if (args.size != 1) {
+                wrongUsage("<number>", event)
+                return@doWhen null
+            }
+
+            val first = args.first()
+            first.toIntOrNull() ?: run {
+                userError("Unknown number $PLEADING_FACE ($first})", event)
+                null
+            }
+        }, {
+            it.getOption("number")?.asInt
+        }) ?: return
+
         if (prNumber < 1) {
-            userError("PR number needs to be positive $PLEADING_FACE")
+            userError("PR number needs to be positive $PLEADING_FACE", event, ephemeral = true)
             return
         }
-        loadPrInfos(prNumber)
-    }
 
+        loadPrInfos(prNumber, event)
+    }
 
-    private fun MessageReceivedEvent.loadPrInfos(prNumber: Int) {
-        logAction("loads pr infos for #$prNumber")
+    private fun loadPrInfos(prNumber: Int, event: Any) {
+        when (event) {
+            is MessageReceivedEvent -> logAction("loads pr infos for #$prNumber", event)
+            is SlashCommandInteractionEvent -> logAction("loads pr infos for #$prNumber", event)
+        }
 
         val prLink = "$BASE/pull/$prNumber"
 
-        val pr = try {
-            github.findPullRequest(prNumber) ?: run {
-                reply("pr is null!")
-                return
-            }
-        } catch (e: IllegalStateException) {
-            if (e.message?.contains(" code:404 ") == true) {
-                val issueUrl = "$BASE/issues/$prNumber"
-                val issue = "issue".linkTo(issueUrl)
-                val text = "This pull request does not yet exist or is an $issue"
-                reply(embed("Not found $PLEADING_FACE", text, Color.red))
-                return
-            }
-            reply("Could not load pull request infos for #$prNumber: ${e.message}")
-            return
-        }
+        val pr =
+            runCatching { github.findPullRequest(prNumber) }.getOrElse { handlePrError(prNumber, event, it); return }
+                ?: return
 
         val head = pr.head
         val userName = head.user.login
-        val userProfile = "https://github.com/$userName"
         val prNumberDisplay = "#$prNumber".linkTo(prLink)
-        val userNameDisplay = userName.linkTo(userProfile)
+        val userNameDisplay = userName.linkTo("https://github.com/$userName")
         val embedTitle = pr.title
-        val title = buildString {
-            append("> $prNumberDisplay by $userNameDisplay")
-            append("\n")
-        }
-
-        val time = buildString {
-            val lastUpdate = passedSince(pr.updatedAt)
-            val created = passedSince(pr.createdAt)
-            append("> Created: $created")
-            append("\n")
-            append("> Last Updated: $lastUpdate")
-            append("\n")
-        }
-
-        val lastCommit = head.sha
-
-        val job = github.getRun(lastCommit, "Build and test") ?: run {
-            val text = "${title}${time} \nArtifact does not exist $PLEADING_FACE (expired or first pr of contributor)"
-            reply(embed(embedTitle, text, readColor(pr)))
+        val title = "> $prNumberDisplay by $userNameDisplay\n"
+        val time = "> Created: ${passedSince(pr.createdAt)}\n> Last Updated: ${passedSince(pr.updatedAt)}\n"
+
+        val job = github.getRun(head.sha, "Build and test") ?: run {
+            reply(
+                embed(
+                    embedTitle,
+                    "$title$time \nArtifact does not exist $PLEADING_FACE (expired or first PR of contributor)",
+                    readColor(pr)
+                ),
+                event
+            )
             return
         }
 
         if (job.startedAt?.let { toTimeMark(it).passedSince() > 90.days } == true) {
-            reply(embed(embedTitle, "${title}${time} \nartifact has expired $PLEADING_FACE", readColor(pr)))
+            reply(embed(embedTitle, "$title$time \nArtifact has expired $PLEADING_FACE", readColor(pr)), event)
             return
         }
 
         if (job.status != Status.COMPLETED) {
-            val text = when (job.status) {
-                Status.REQUESTED -> "Run has been requested $PLEADING_FACE"
-                Status.QUEUED -> "Run is in queue $PLEADING_FACE"
-                Status.IN_PROGRESS -> "Run is in progress $PLEADING_FACE"
-                Status.WAITING -> "Run is waiting $PLEADING_FACE"
-                Status.PENDING -> "Run is pending $PLEADING_FACE"
-                else -> ""
-            }
-            reply(embed(embedTitle, "${title}${time} \n $text", readColor(pr)))
+            val statusText = mapOf(
+                Status.REQUESTED to "Run has been requested $PLEADING_FACE",
+                Status.QUEUED to "Run is in queue $PLEADING_FACE",
+                Status.IN_PROGRESS to "Run is in progress $PLEADING_FACE",
+                Status.WAITING to "Run is waiting $PLEADING_FACE",
+                Status.PENDING to "Run is pending $PLEADING_FACE"
+            )[job.status] ?: ""
+            reply(embed(embedTitle, "$title$time \n$statusText", readColor(pr)), event)
             return
         }
 
-        val match = job.htmlUrl?.let { runIdRegex.matchEntire(it) }
-        val runId = match?.groups?.get("RunId")?.value
-
+        val runId = job.htmlUrl?.let { runIdRegex.matchEntire(it)?.groups?.get("RunId")?.value }
         val artifactLink = "$BASE/actions/runs/$runId?pr=$prNumber"
         val nightlyLink = "https://nightly.link/$USER/$REPO/actions/runs/$runId/Development%20Build.zip"
-        val artifactLine = "GitHub".linkTo(artifactLink)
-        val nightlyLine = "Nightly".linkTo(nightlyLink)
-
-        val artifactDisplay = buildString {
-            append(" \n")
-            append("Download the latest development build of this pr!")
-            append("\n")
-            append("> From $artifactLine (requires a GitHub Account)")
-            append("\n")
-            append("> From $nightlyLine (unofficial)")
-            append("\n")
-            append("> (updated ${passedSince(job.completedAt ?: "")})")
-        }
+        val artifactDisplay =
+            "\nDownload the latest development build of this PR!\n> From ${"GitHub".linkTo(artifactLink)} (requires a GitHub Account)\n> From ${
+                "Nightly".linkTo(nightlyLink)
+            } (unofficial)\n> (updated ${passedSince(job.completedAt ?: "")})"
 
-        reply(embed(embedTitle, "$title$time$artifactDisplay", readColor(pr)))
+        reply(embed(embedTitle, "$title$time$artifactDisplay", readColor(pr)), event)
+    }
+
+    private fun handlePrError(prNumber: Int, event: Any, e: Throwable) {
+        if (e is IllegalStateException && e.message?.contains(" code:404 ") == true) {
+            val text = "This pull request does not yet exist or is an ${"issue".linkTo("$BASE/issues/$prNumber")}"
+            reply(embed("Not found $PLEADING_FACE", text, Color.red), event, ephemeral = true)
+            return
+        }
+        reply("Could not load pull request infos for #$prNumber: ${e.message}", event, ephemeral = true)
     }
 
     // Colors picked from GitHub
@@ -169,57 +160,57 @@ object PullRequestCommand : BaseCommand() {
     @Suppress("unused") // TODO implement once we can upload the file
     private fun MessageReceivedEvent.pullRequestArtifactCommand(args: List<String>) {
         if (args.size != 2) {
-            reply("Usage: `!prupload <number>`")
+            reply("Usage: `!prupload <number>`", this)
             return
         }
         val prNumber = args[1].toIntOrNull() ?: run {
-            reply("unknwon number $PLEADING_FACE (${args[1]})")
+            reply("unknwon number $PLEADING_FACE (${args[1]})", this)
             return
         }
 
         val prLink = "$BASE/pull/$prNumber"
-        reply("Looking for pr <$prLink..")
+        reply("Looking for pr <$prLink..", this)
 
         val pr = github.findPullRequest(prNumber) ?: run {
-            reply("pr is null!")
+            reply("pr is null!", this)
             return
         }
         val head = pr.head
-        reply("found pr `${pr.title}` (from `${head.user.login}`)")
+        reply("found pr `${pr.title}` (from `${head.user.login}`)", this)
 
-        reply("looking for artifact ..")
+        reply("looking for artifact ..", this)
         val lastCommit = head.sha
         val artifact = github.findArtifact(lastCommit) ?: run {
-            reply("artifact is null!")
+            reply("artifact is null!", this)
             return
         }
-        reply("found artifact")
+        reply("found artifact", this)
 
         val artifactId = artifact.id
         val fileRaw = File("temp/downloads/artifact-$artifactId-raw")
         fileRaw.createParentDirIfNotExist()
         val fileUnzipped = File("temp/downloads/artifact-$artifactId-unzipped")
-        reply("Downloading artifact ..")
+        reply("Downloading artifact ..", this)
         val (_, downloadTime) = timeExecution {
             github.downloadArtifact(artifactId, fileRaw)
         }
-        reply("artifact downnloaded in ${downloadTime.format()}")
+        reply("artifact downnloaded in ${downloadTime.format()}", this)
 
-        Utils.unzipFile(fileRaw, fileUnzipped)
+        unzipFile(fileRaw, fileUnzipped)
         fileRaw.delete()
 
         val displayUrl = "$BASE/actions/runs/$artifactId?pr=$prNumber"
 
         val modJar = findJarFile(fileUnzipped) ?: run {
-            reply("mod jar not found!")
+            reply("mod jar not found!", this)
             return
         }
 
-        reply("start uploading..")
+        reply("start uploading..", this)
         val (_, uploadTime) = timeExecution {
             channel.uploadFile(modJar, "here is the jar from <$displayUrl>")
         }
-        reply("Mod jar uploaded in ${uploadTime.format()}")
+        reply("Mod jar uploaded in ${uploadTime.format()}", this)
     }
 
     private fun findJarFile(directory: File): File? {
@@ -235,8 +226,29 @@ object PullRequestCommand : BaseCommand() {
                 consumer.message.messageDelete()
             }
         }
-        event.loadPrInfos(pr)
+        loadPrInfos(pr, this)
         return true
     }
-
-}
\ No newline at end of file
+}
+
+//object SlashPullRequestCommand : SlashCommand() {
+//    override val name = "pr"
+//    override val description = "Displays useful information about a pull request on GitHub."
+//    override val options: List<SlashOption> = listOf(
+//        SlashOption("number", "Number of the pull request you want to display.", type = OptionType.INTEGER)
+//    )
+//
+//    override val userCommand: Boolean = true
+//
+//    override fun SlashCommandInteractionEvent.execute() {
+//        getOption("number")?.let {
+//            val prNumber = it.asInt
+//            if (prNumber < 1) {
+//                replyT("PR number needs to be positive $PLEADING_FACE")
+//                return
+//            }
+//
+//            loadPrInfos(prNumber, this)
+//        }
+//    }
+//}
\ No newline at end of file
diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/ServerCommands.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/ServerCommands.kt
index fac18f7..785b70f 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/ServerCommands.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/ServerCommands.kt
@@ -3,6 +3,7 @@ package at.hannibal2.skyhanni.discord.command
 import at.hannibal2.skyhanni.discord.BOT
 import at.hannibal2.skyhanni.discord.Option
 import at.hannibal2.skyhanni.discord.Utils
+import at.hannibal2.skyhanni.discord.Utils.doWhen
 import at.hannibal2.skyhanni.discord.Utils.logAction
 import at.hannibal2.skyhanni.discord.Utils.reply
 import at.hannibal2.skyhanni.discord.Utils.sendMessageToBotChannel
@@ -11,6 +12,7 @@ import at.hannibal2.skyhanni.discord.github.GitHubClient
 import com.google.gson.Gson
 import com.google.gson.reflect.TypeToken
 import net.dv8tion.jda.api.events.message.MessageReceivedEvent
+import net.dv8tion.jda.api.interactions.commands.OptionType
 import kotlin.time.Duration.Companion.milliseconds
 
 object ServerCommands {
@@ -115,7 +117,7 @@ object ServerCommands {
         }
     }
 
-    internal fun getServer(name: String): Server? {
+    fun getServer(name: String): Server? {
         for (server in servers) {
             if (server.keyword.equals(name, ignoreCase = true)) {
                 return server
@@ -138,14 +140,25 @@ object ServerCommands {
     fun isKnownServerUrl(event: MessageReceivedEvent, message: String): Boolean {
         val server = getServerByInviteUrl(message) ?: run {
             if (isDiscordInvite(message)) {
-                event.logAction("sends unknown discord invite '$message'")
+                logAction("sends unknown discord invite '$message'", event)
             }
             return false
         }
 
-        event.reply(server.print(tutorial = true))
+        reply(server.print(tutorial = true), event)
         return true
     }
+
+    fun listServers(): String {
+        if (servers.isEmpty()) return "No servers found."
+
+        val list = servers.joinToString("\n") { server ->
+            val aliases = server.aliases
+            if (aliases.isNotEmpty()) "${server.keyword} [${aliases.joinToString(", ")}]"
+            else server.keyword
+        }
+        return "Server list:\n$list"
+    }
 }
 
 @Suppress("unused")
@@ -153,26 +166,37 @@ class ServerCommand : BaseCommand() {
     override val name: String = "server"
     override val description: String = "Displays information about a server from our 'useful server list'."
     override val options: List<Option> = listOf(
-        Option("keyword", "Keyword of the server you want to display."),
-        Option("debug", "Display even more useful information (-d to use).", required = false)
+        Option("keyword", "Keyword of the server you want to display.", autoComplete = true),
+        Option(
+            "debug",
+            "Display even more useful information (-d to use).",
+            required = false,
+            type = OptionType.BOOLEAN
+        )
     )
     override val userCommand: Boolean = true
 
-    override fun MessageReceivedEvent.execute(args: List<String>) {
-        if (args.size !in 1..2) {
-            wrongUsage("<keyword>")
-        }
-        val keyword = args.first()
-        val debug = args.getOrNull(1) == "-d"
+    override fun execute(args: List<String>, event: Any) {
+        val keyword = doWhen(event, {
+            if (args.size !in 1..2) {
+                wrongUsage("<keyword>", event)
+            }
+
+            args.first()
+        }, {
+            it.getOption("keyword")?.asString
+        }) ?: return
+
+
+        val debug = doWhen(event, { args.getOrNull(1) == "-d" }, { it.getOption("debug")?.asBoolean == true }) ?: false
         val server = ServerCommands.getServer(keyword.lowercase())
         if (server == null) {
-            userError("Server with keyword '$keyword' not found.")
+            userError("Server with keyword '$keyword' not found.", event, ephemeral = true)
             return
         }
-        if (debug) reply(server.printDebug())
-        else reply(server.print())
+        if (debug) reply(server.printDebug(), event)
+        else reply(server.print(), event)
     }
-
 }
 
 @Suppress("unused")
@@ -181,12 +205,14 @@ class ServerUpdate : BaseCommand() {
     override val description: String = "Updates the server list."
     override val aliases: List<String> = listOf("updateservers")
 
-    override fun MessageReceivedEvent.execute(args: List<String>) {
+    override fun execute(args: List<String>, event: Any) {
         ServerCommands.loadServers(startup = false)
-        reply("Updated server list from [GitHub](<https://github.com/SkyHanniStudios/DiscordBot/blob/master/data/discord_servers.json>).")
-        logAction("updated server list from github")
+        reply(
+            "Updated server list from [GitHub](<https://github.com/SkyHanniStudios/DiscordBot/blob/master/data/discord_servers.json>).",
+            event
+        )
+        logAction("updated server list from github", event)
     }
-
 }
 
 @Suppress("unused")
@@ -195,16 +221,7 @@ class ServerList : BaseCommand() {
     override val description: String = "Displays all servers in the database."
     override val aliases: List<String> = listOf("servers")
 
-    override fun MessageReceivedEvent.execute(args: List<String>) {
-        if (ServerCommands.servers.isEmpty()) {
-            reply("No servers found.")
-            return
-        }
-        val list = ServerCommands.servers.joinToString("\n") { server ->
-            val aliases = server.aliases
-            if (aliases.isNotEmpty()) "${server.keyword} [${aliases.joinToString(", ")}]"
-            else server.keyword
-        }
-        reply("Server list:\n$list")
+    override fun execute(args: List<String>, event: Any) {
+        reply(ServerCommands.listServers(), event, ephemeral = true)
     }
 }
\ No newline at end of file
diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/TagCommands.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/TagCommands.kt
index 9768e71..4043961 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/TagCommands.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/TagCommands.kt
@@ -1,11 +1,16 @@
 package at.hannibal2.skyhanni.discord.command
 
-import at.hannibal2.skyhanni.discord.*
+import at.hannibal2.skyhanni.discord.CommandListener
+import at.hannibal2.skyhanni.discord.Database
+import at.hannibal2.skyhanni.discord.Option
+import at.hannibal2.skyhanni.discord.PLEADING_FACE
+import at.hannibal2.skyhanni.discord.Utils.doWhen
 import at.hannibal2.skyhanni.discord.Utils.logAction
 import at.hannibal2.skyhanni.discord.Utils.messageDelete
 import at.hannibal2.skyhanni.discord.Utils.messageDeleteAndThen
 import at.hannibal2.skyhanni.discord.Utils.reply
 import at.hannibal2.skyhanni.discord.Utils.replyWithConsumer
+import at.hannibal2.skyhanni.discord.Utils.runDelayed
 import at.hannibal2.skyhanni.discord.Utils.sendError
 import at.hannibal2.skyhanni.discord.Utils.sendMessageWithConsumer
 import at.hannibal2.skyhanni.discord.Utils.userError
@@ -35,28 +40,28 @@ object TagCommands {
             deleting = true
         }
         val response = Database.getResponse(keyword) ?: run {
-            event.reply("Unknown command $PLEADING_FACE Type `!help` for help.")
+            reply("Unknown command $PLEADING_FACE Type `!help` for help.", event)
             return false
         }
 
         val author = message.author.id
         lastTouchedTag[author] = keyword
         message.referencedMessage?.let {
-            event.logAction("used keyword '$keyword' (with reply)")
+            logAction("used keyword '$keyword' (with reply)", event)
             message.messageDelete()
             it.replyWithConsumer(response) { consumer ->
                 addLastMessage(author, consumer.message)
             }
         } ?: run {
             if (deleting) {
-                event.logAction("used keyword '$keyword' (with delete)")
+                logAction("used keyword '$keyword' (with delete)", event)
                 message.messageDeleteAndThen {
                     event.channel.sendMessageWithConsumer(response) { consumer ->
                         addLastMessage(author, consumer.message)
                     }
                 }
             } else {
-                event.logAction("used keyword '$keyword'")
+                logAction("used keyword '$keyword'", event)
                 addLastMessage(author, message)
                 message.replyWithConsumer(response) { consumer ->
                     addLastMessage(author, consumer.message)
@@ -74,10 +79,10 @@ class TagList : BaseCommand() {
     override val aliases = listOf("tags")
     override val userCommand: Boolean = true
 
-    override fun MessageReceivedEvent.execute(args: List<String>) {
+    override fun execute(args: List<String>, event: Any) {
         val list = Database.listKeywords()
         val keywords = list.joinToString(", !", prefix = "!")
-        reply(if (list.isNotEmpty()) "📌 All ${list.size} keywords: $keywords" else "No keywords set.")
+        reply(if (list.isNotEmpty()) "📌 All ${list.size} keywords: $keywords" else "No keywords set.", event)
     }
 }
 
@@ -86,32 +91,45 @@ class TagEdit : BaseCommand() {
     override val name = "tagedit"
     override val description = "Edits a tag in the database."
     override val options: List<Option> = listOf(
-        Option("tag", "The tag you want to edit."),
+        Option("tag", "The tag you want to edit.", autoComplete = true),
         Option("response", "Response you want the tag to have.")
     )
     override val aliases = listOf("tagchange")
 
-    override fun MessageReceivedEvent.execute(args: List<String>) {
-        if (args.size < 2) return wrongUsage("<tag> <response>")
-        val keyword = args.first()
-        val response = args.drop(1).joinToString(" ")
+    override fun execute(args: List<String>, event: Any) {
+        val keyword = doWhen(event,
+            {
+                if (args.size < 2) {
+                    wrongUsage("<tag> <response>", event)
+                    return@doWhen null
+                }
+
+                args.first()
+            },
+            { it.getOption("tag")?.asString }
+        ) ?: return
+
+        val response =
+            doWhen(event, { args.drop(1).joinToString(" ") }, { it.getOption("response")?.asString }) ?: return
+
         val oldResponse = Database.getResponse(keyword)
         if (oldResponse == null) {
-            userError("❌ Keyword doesn't exist! Use `!tagadd` instead.")
+            userError("Keyword doesn't exist! Use `!tagadd` instead.", event, ephemeral = true)
             return
         }
         if (Database.addKeyword(keyword, response)) {
-            message.messageDeleteAndThen {
-                val id = author.id
-                reply("✅ Keyword '$keyword' edited by <@$id>:")
-                reply(response)
-                logAction("edited keyword '$keyword'")
-                logAction("old response: '$oldResponse'", raw = true)
-                logAction("new response: '$response'", raw = true)
-                lastTouchedTag[id] = keyword
-            }
+            doWhen(event, { it.message.messageDelete() }, {})
+
+            val id = doWhen(event, { it.author.id }, { it.user.id }).toString()
+
+            reply("✅ Keyword '$keyword' edited by <@$id>:", event)
+            doWhen(event, { reply(response, it) }, { it.channel.sendMessage(response).queue() })
+            logAction("edited keyword '$keyword'", event)
+            logAction("old response: '$oldResponse'", event, raw = true)
+            logAction("new response: '$response'", event, raw = true)
+            lastTouchedTag[id] = keyword
         } else {
-            sendError("❌ Failed to edit keyword.")
+            sendError("❌ Failed to edit keyword.", event, ephemeral = true)
         }
     }
 }
@@ -121,15 +139,20 @@ class TagEditLast : BaseCommand() {
     override val name = "tageditlast"
     override val description = "Show info on how to edit the last tag used."
 
-    override fun MessageReceivedEvent.execute(args: List<String>) {
-        val id = author.id
+    override fun execute(args: List<String>, event: Any) {
+        val id = doWhen(event, { it.author.id }, { it.user.id }).toString()
+
         val lastTag = lastTouchedTag[id] ?: run {
-            return userError("No last tag found $PLEADING_FACE")
+            return userError("No last tag found $PLEADING_FACE", event, ephemeral = true)
         }
         val response = Database.getResponse(lastTag) ?: run {
-            return sendError("Last tag `$lastTag` got deleted, this should not happen, therefore we ping <@239858538959077376>")
+            return sendError(
+                "Last tag `$lastTag` got deleted, this should not happen, therefore we ping <@239858538959077376>",
+                event,
+                ephemeral = true
+            )
         }
-        reply("```!tagedit $lastTag $response```")
+        reply("```!tagedit $lastTag $response```", event, ephemeral = true)
     }
 }
 
@@ -143,26 +166,42 @@ class TagAdd : BaseCommand() {
     )
     override val aliases = listOf("tagcreate")
 
-    override fun MessageReceivedEvent.execute(args: List<String>) {
-        if (args.size < 2) return wrongUsage("<keyword> <response>")
-        val keyword = args.first()
+    override fun execute(args: List<String>, event: Any) {
+        val keyword = doWhen(event, {
+            if (args.size < 2) {
+                wrongUsage("<keyword> <response>", event)
+                return@doWhen null
+            }
+            args.first()
+        }, {
+            it.getOption("keyword")?.asString
+        }) ?: return
+
+
         if (CommandListener.existsCommand(keyword)) {
-            return userError("❌ Can not create keyword `!$keyword`. There is already a command with that name")
+            return userError(
+                "Can not create keyword `!$keyword`. There is already a command with that name",
+                event,
+                ephemeral = true
+            )
         }
-        val response = args.drop(1).joinToString(" ")
+        val response =
+            doWhen(event, { args.drop(1).joinToString(" ") }, { it.getOption("response")?.asString }) ?: return
+
         if (Database.containsKeyword(keyword)) {
-            return userError("❌ Keyword already exists. Use `!tagedit` instead.")
+            return userError("Keyword already exists. Use `!tagedit` instead.", event, ephemeral = true)
         }
         if (Database.addKeyword(keyword, response)) {
-            message.messageDeleteAndThen {
-                reply("✅ Keyword '$keyword' added by ${author.asMention}:")
-                reply(response)
-                logAction("added keyword '$keyword'")
-                logAction("response: '$response'", raw = true)
-                lastTouchedTag[author.id] = keyword
-            }
+            doWhen(event, { it.message.messageDelete() }, {})
+            val author = doWhen(event, { it.author }, { it.user }) ?: return
+
+            reply("✅ Keyword '$keyword' added by ${author.asMention}:", event)
+            doWhen(event, { reply(response, event) }, { it.channel.sendMessage(response).queue() })
+            logAction("added keyword '$keyword'", event)
+            logAction("response: '$response'", event, raw = true)
+            lastTouchedTag[author.id] = keyword
         } else {
-            sendError("❌ Failed to add keyword.")
+            sendError("❌ Failed to add keyword.", event, ephemeral = true)
         }
     }
 }
@@ -172,25 +211,32 @@ class TagDelete : BaseCommand() {
     override val name: String = "tagdelete"
     override val description: String = "Deletes a tag from the database."
     override val options: List<Option> = listOf(
-        Option("keyword", "Keyword of the tag you want to delete.")
+        Option("keyword", "Keyword of the tag you want to delete.", autoComplete = true)
     )
     override val aliases: List<String> = listOf("tagremove")
 
-    override fun MessageReceivedEvent.execute(args: List<String>) {
-        if (args.isEmpty()) return wrongUsage("<keyword>")
-        val keyword = args.first()
+    override fun execute(args: List<String>, event: Any) {
+        val keyword = doWhen(event, {
+            if (args.isEmpty()) {
+                wrongUsage("<keyword>", event)
+                return@doWhen null
+            }
+
+            args.first()
+        }, { it.getOption("keyword")?.asString }) ?: return
+
         val oldResponse = Database.getResponse(keyword)
+
         if (Database.deleteKeyword(keyword)) {
-            reply("🗑️ Keyword '$keyword' deleted!")
-            logAction("deleted keyword '$keyword'")
-            logAction("response was: '$oldResponse'", raw = true)
-            val id = author.id
+            reply("🗑️ Keyword '$keyword' deleted!", event)
+            logAction("deleted keyword '$keyword'", event)
+            logAction("response was: '$oldResponse'", event, raw = true)
+            val id = doWhen(event, { it.author.id }, { it.user.id })
             lastTouchedTag.remove(id)
         } else {
-            userError("❌ Keyword '$keyword' not found.")
+            userError("Keyword '$keyword' not found.", event, ephemeral = true)
         }
     }
-
 }
 
 @Suppress("unused")
@@ -200,32 +246,36 @@ class TagUndo : BaseCommand() {
     override val userCommand: Boolean = true
     override val aliases: List<String> = listOf("undo")
 
-    override fun MessageReceivedEvent.execute(args: List<String>) {
-        val author = author.id
-        val message = message
+    override fun execute(args: List<String>, event: Any) {
+        val author = doWhen(event, { it.author.id }, { it.user.id }) ?: return
         if (undo(author)) {
-            logAction("undid last send tag.")
+            logAction("undid last send tag.", event)
             lastTouchedTag.remove(author)
-            message.messageDelete()
+            doWhen(event, { it.message.messageDelete() }, { reply("Undid last sent tag.", event, ephemeral = true) })
         } else {
-            addLastMessage(author, message)
-            message.replyWithConsumer("No last tag to undo found!") { consumer ->
-                addLastMessage(author, consumer.message)
-            }
-            Utils.runDelayed(2.seconds) {
-                undo(author)
-            }
+            doWhen(
+                event, {
+                    addLastMessage(author, it.message)
+                    it.message.replyWithConsumer("No last tag to undo found!") { consumer ->
+                        addLastMessage(author, consumer.message)
+                    }
+                    runDelayed(2.seconds) {
+                        undo(author)
+                    }
+                }, {
+                    sendError("No last tag to undo found!", event)
+                }
+            )
         }
     }
+}
 
-    private fun undo(author: String): Boolean {
-        return lastMessages[author]?.let {
-            for (message in it) {
-                message.messageDelete()
-            }
-            lastMessages.remove(author)
-            true
-        } ?: false
-    }
-
+fun undo(author: String): Boolean {
+    return lastMessages[author]?.let {
+        for (message in it) {
+            message.messageDelete()
+        }
+        lastMessages.remove(author)
+        true
+    } ?: false
 }
\ No newline at end of file

From f48c76e3f0c758b63602d5c30d5f5af5ef41ffe3 Mon Sep 17 00:00:00 2001
From: ILike2WatchMemes <ilike2watchmemes@gmail.com>
Date: Sun, 9 Mar 2025 23:45:26 +0100
Subject: [PATCH 2/9] add autocomplete for tagedit and delete

tag -> keyword for tagedit
---
 .../skyhanni/discord/CommandListener.kt        | 18 ++++++++++++++++++
 .../skyhanni/discord/command/TagCommands.kt    |  6 +++---
 2 files changed, 21 insertions(+), 3 deletions(-)

diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt
index f2b43a1..812a4de 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt
@@ -152,6 +152,24 @@ object CommandListener {
                         .take(25)
                 ).queue()
             }
+
+            "tagedit" -> {
+                if (focusedOption.name != "keyword") return
+
+                replyChoiceStrings(
+                    Database.listKeywords().filter { it.startsWith(focusedOption.value, true) }
+                        .take(25)
+                ).queue()
+            }
+
+            "tagdelete" -> {
+                if (focusedOption.name != "keyword") return
+
+                replyChoiceStrings(
+                    Database.listKeywords().filter { it.startsWith(focusedOption.value, true) }
+                        .take(25)
+                ).queue()
+            }
         }
     }
 
diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/TagCommands.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/TagCommands.kt
index 4043961..10c6d6d 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/TagCommands.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/TagCommands.kt
@@ -91,7 +91,7 @@ class TagEdit : BaseCommand() {
     override val name = "tagedit"
     override val description = "Edits a tag in the database."
     override val options: List<Option> = listOf(
-        Option("tag", "The tag you want to edit.", autoComplete = true),
+        Option("keyword", "The tag you want to edit.", autoComplete = true),
         Option("response", "Response you want the tag to have.")
     )
     override val aliases = listOf("tagchange")
@@ -100,13 +100,13 @@ class TagEdit : BaseCommand() {
         val keyword = doWhen(event,
             {
                 if (args.size < 2) {
-                    wrongUsage("<tag> <response>", event)
+                    wrongUsage("<keyword> <response>", event)
                     return@doWhen null
                 }
 
                 args.first()
             },
-            { it.getOption("tag")?.asString }
+            { it.getOption("keyword")?.asString }
         ) ?: return
 
         val response =

From 9e8ed00a98038b8b5cadd7e73b1e6d026df3d3c4 Mon Sep 17 00:00:00 2001
From: ILike2WatchMemes <ilike2watchmemes@gmail.com>
Date: Sun, 9 Mar 2025 23:50:12 +0100
Subject: [PATCH 3/9] make createHelpEmbed private

---
 .../skyhanni/discord/command/HelpCommand.kt   | 26 +++++++++----------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/HelpCommand.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/HelpCommand.kt
index 661d1dc..9c77fcf 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/HelpCommand.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/HelpCommand.kt
@@ -71,7 +71,6 @@ object HelpCommand : BaseCommand() {
         }
     }
 
-
     fun sendUsageReply(commandName: String, event: Any) {
         val command = CommandListener.getCommand(commandName) ?: run {
             reply("Unknown command `!$commandName` $PLEADING_FACE", event)
@@ -85,20 +84,21 @@ object HelpCommand : BaseCommand() {
 
         reply(createHelpEmbed(commandName), event)
     }
-}
 
-fun BaseCommand.createHelpEmbed(commandName: String): MessageEmbed {
-    val em = EmbedBuilder()
+    private fun BaseCommand.createHelpEmbed(commandName: String): MessageEmbed {
+        val em = EmbedBuilder()
 
-    em.setTitle("Usage: /$commandName <" + this.options.joinToString("> <") { it.name } + ">")
-    em.setDescription("📋 **${this.description}**")
-    em.setColor(Color.GREEN)
+        em.setTitle("Usage: /$commandName <" + this.options.joinToString("> <") { it.name } + ">")
+        em.setDescription("📋 **${this.description}**")
+        em.setColor(Color.GREEN)
 
-    for (option in this.options) {
-        em.addField(option.name, option.description, true)
-        em.addField("Required", if (option.required) "✅" else "❌", true)
-        em.addBlankField(true)
+        for (option in this.options) {
+            em.addField(option.name, option.description, true)
+            em.addField("Required", if (option.required) "✅" else "❌", true)
+            em.addBlankField(true)
+        }
+
+        return em.build()
     }
+}
 
-    return em.build()
-}
\ No newline at end of file

From 9bbf294a5a10630fdc94ae3b2f2d68f35035ffbb Mon Sep 17 00:00:00 2001
From: ILike2WatchMemes <ilike2watchmemes@gmail.com>
Date: Tue, 11 Mar 2025 16:35:49 +0100
Subject: [PATCH 4/9] update

---
 .../at/hannibal2/skyhanni/discord/CommandListener.kt      | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt
index a4c5928..6c947c0 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt
@@ -92,7 +92,7 @@ object CommandListener {
         // allows to use `!<command> -help` instead of `!help -<command>`
         if (args.size == 1 && args.first() == "-help") {
             with(HelpCommand) {
-                sendUsageReply(literal)
+                sendUsageReply(literal, this@onMessage)
             }
             return
         }
@@ -146,7 +146,9 @@ object CommandListener {
                 if (focusedOption.name != "command") return
 
                 replyChoiceStrings(
-                    commands.filterKeys { key -> key.startsWith(focusedOption.value) }.keys
+                    commands.filter { it.name.startsWith(focusedOption.value) }
+                        .map { it.name }
+                        .take(25)
                 ).queue()
             }
 
@@ -212,7 +214,7 @@ object CommandListener {
 
     fun createCommands(guild: Guild) {
         guild.retrieveCommands().queue {
-            val commandData = commands.values.map { value -> convertToData(value) }
+            val commandData = commands.map { value -> convertToData(value) }
 
             guild.updateCommands().addCommands(commandData).queue()
         }

From 2f8b9cdc81e8f3b5e7cc6fb4a74e65e068f8d672 Mon Sep 17 00:00:00 2001
From: ILike2WatchMemes <ilike2watchmemes@gmail.com>
Date: Tue, 11 Mar 2025 20:23:04 +0100
Subject: [PATCH 5/9] add CommandEvent

---
 .../skyhanni/discord/CommandListener.kt       | 155 ++++++++--------
 .../at/hannibal2/skyhanni/discord/Utils.kt    |  91 +---------
 .../skyhanni/discord/command/BaseCommand.kt   |   7 +-
 .../skyhanni/discord/command/CommandEvent.kt  | 114 ++++++++++++
 .../skyhanni/discord/command/HelpCommand.kt   |  52 ++----
 .../discord/command/PullRequestCommand.kt     | 103 +++++------
 .../discord/command/ServerCommands.kt         |  54 +++---
 .../skyhanni/discord/command/TagCommands.kt   | 169 ++++++++----------
 8 files changed, 373 insertions(+), 372 deletions(-)
 create mode 100644 src/main/kotlin/at/hannibal2/skyhanni/discord/command/CommandEvent.kt

diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt
index 6c947c0..269f923 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt
@@ -3,13 +3,10 @@ package at.hannibal2.skyhanni.discord
 import at.hannibal2.skyhanni.discord.Utils.hasAdminPermissions
 import at.hannibal2.skyhanni.discord.Utils.inBotCommandChannel
 import at.hannibal2.skyhanni.discord.Utils.logAction
-import at.hannibal2.skyhanni.discord.Utils.reply
-import at.hannibal2.skyhanni.discord.command.BaseCommand
-import at.hannibal2.skyhanni.discord.command.HelpCommand
-import at.hannibal2.skyhanni.discord.command.PullRequestCommand
-import at.hannibal2.skyhanni.discord.command.ServerCommands
-import at.hannibal2.skyhanni.discord.command.TagCommands
-import at.hannibal2.skyhanni.discord.command.TagUndo
+import at.hannibal2.skyhanni.discord.command.*
+import at.hannibal2.skyhanni.discord.command.PullRequestCommand.isPullRequest
+import at.hannibal2.skyhanni.discord.command.ServerCommands.isKnownServerUrl
+import at.hannibal2.skyhanni.discord.command.TagCommands.handleTag
 import net.dv8tion.jda.api.entities.Guild
 import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
@@ -29,6 +26,9 @@ object CommandListener {
 
     fun init() {
         loadCommands()
+
+        BOT.jda.awaitReady()
+
         BOT.jda.getGuildById(BOT.config.allowedServerId)?.let { createCommands(it) }
     }
 
@@ -45,98 +45,99 @@ object CommandListener {
     }
 
     private fun MessageReceivedEvent.onMessage(bot: DiscordBot) {
-        val message = message.contentRaw.trim()
-        if (!isFromGuild) {
-            logAction("private dm: '$message'", this)
-            return
-        }
-        if (guild.id != bot.config.allowedServerId) return
-
-        if (this.author.isBot) {
-            if (this.author.id == BOT_ID) {
-                BotMessageHandler.handle(this)
+        with(MessageEvent(this)) {
+            val message = message.contentRaw.trim()
+            if (!isFromGuild) {
+                logAction("private dm: '$message'")
+                return
             }
-            return
-        }
-
-        if (TagUndo.getAllNames().none { "!$it" == message }) {
-            TagCommands.lastMessages.remove(this.author.id)
-        }
+            if (guild.id != bot.config.allowedServerId) return
 
-        if (ServerCommands.isKnownServerUrl(this, message)) return
-        if (PullRequestCommand.isPullRequest(this, message)) return
+            if (author.isBot) {
+                if (author.id == BOT_ID) {
+                    BotMessageHandler.handle(event)
+                }
+                return
+            }
 
-        if (!isCommand(message)) return
+            if (TagUndo.getAllNames().none { "!$it" == message }) {
+                TagCommands.lastMessages.remove(author.id)
+            }
 
-        val split = message.substring(1).split(" ")
-        val literal = split.first().lowercase()
-        val args = split.drop(1)
+            if (isKnownServerUrl(message) || isPullRequest(message) || !isCommand(message)) return
 
-        val command = getCommand(literal) ?: run {
-            TagCommands.handleTag(this)
-            return
-        }
+            val split = message.substring(1).split(" ")
+            val literal = split.first().lowercase()
+            val args = split.drop(1)
 
-        if (!command.userCommand) {
-            if (!hasAdminPermissions(this)) {
-                reply("No permissions $PLEADING_FACE", this)
+            val command = getCommand(literal) ?: run {
+                handleTag()
                 return
             }
 
-            if (!inBotCommandChannel(this)) {
-                reply("Wrong channel $PLEADING_FACE", this)
-                return
-            }
-        }
+            if (!command.userCommand) {
+                if (!hasAdminPermissions()) {
+                    reply("No permissions $PLEADING_FACE")
+                    return
+                }
 
-        // allows to use `!<command> -help` instead of `!help -<command>`
-        if (args.size == 1 && args.first() == "-help") {
-            with(HelpCommand) {
-                sendUsageReply(literal, this@onMessage)
+                if (!inBotCommandChannel()) {
+                    reply("Wrong channel $PLEADING_FACE")
+                    return
+                }
             }
-            return
-        }
-        // allows to use `!<command> -help` instead of `!help -<command>`
-        if (args.size == 1) {
-            if (args.first() == "-help") {
+
+            // allows to use `!<command> -help` instead of `!help -<command>`
+            if (args.size == 1 && args.first() == "-help") {
                 with(HelpCommand) {
-                    this.sendUsageReply(literal, this@onMessage)
+                    sendUsageReply(literal)
                 }
                 return
             }
-        }
-        try {
-            with(command) {
-                execute(args, this@onMessage)
+            // allows to use `!<command> -help` instead of `!help -<command>`
+            if (args.size == 1) {
+                if (args.first() == "-help") {
+                    with(HelpCommand) {
+                        sendUsageReply(literal)
+                    }
+                    return
+                }
+            }
+            try {
+                with(command) {
+                    execute(args)
+                }
+            } catch (e: Exception) {
+                reply("Error: ${e.message}")
             }
-        } catch (e: Exception) {
-            reply("Error: ${e.message}", this)
         }
     }
 
     private fun SlashCommandInteractionEvent.onInteraction(bot: DiscordBot) {
-        if (guild?.id != bot.config.allowedServerId || this.user.isBot) return
+        with(SlashCommandEvent(this)) {
+            if (guild?.id != bot.config.allowedServerId || user.isBot) return
 
-        val command = getCommand(this.fullCommandName) ?: return
+            val command = getCommand(event.fullCommandName) ?: return
 
-        if (!command.userCommand) {
-            if (!hasAdminPermissions(this)) {
-                reply("No permissions $PLEADING_FACE")
-                return
-            }
+            if (!command.userCommand) {
+                if (!hasAdminPermissions()) {
+                    reply("No permissions $PLEADING_FACE")
+                    return
+                }
 
-            if (!inBotCommandChannel(this)) {
-                reply("Wrong channel $PLEADING_FACE")
-                return
+                if (!inBotCommandChannel()) {
+                    reply("Wrong channel $PLEADING_FACE")
+                    return
+                }
             }
-        }
 
-        try {
-            with(command) {
-                execute(listOf(), this@onInteraction)
+            try {
+                with(command) {
+                    execute(listOf())
+                }
+            } catch (e: Exception) {
+                reply("Error: ${e.message}")
             }
-        } catch (e: Exception) {
-            reply("Error: ${e.message}")
         }
     }
 
@@ -210,11 +211,17 @@ object CommandListener {
                 e.printStackTrace()
             }
         }
+        this.commands = commands
+        this.commandsMap = commandsMap
     }
 
-    fun createCommands(guild: Guild) {
+    private fun createCommands(guild: Guild) {
         guild.retrieveCommands().queue {
             val commandData = commands.map { value -> convertToData(value) }
+            println(getCommand("server"))
+
+            println(commandsMap)
+            println(commandData)
 
             guild.updateCommands().addCommands(commandData).queue()
         }
diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/Utils.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/Utils.kt
index 899c93b..c4402af 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/Utils.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/Utils.kt
@@ -1,13 +1,12 @@
 package at.hannibal2.skyhanni.discord
 
+import at.hannibal2.skyhanni.discord.command.CommandEvent
 import net.dv8tion.jda.api.EmbedBuilder
-import net.dv8tion.jda.api.entities.Member
 import net.dv8tion.jda.api.entities.Message
 import net.dv8tion.jda.api.entities.MessageEmbed
 import net.dv8tion.jda.api.entities.channel.concrete.TextChannel
 import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel
 import net.dv8tion.jda.api.entities.channel.unions.MessageChannelUnion
-import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
 import net.dv8tion.jda.api.events.message.MessageReceivedEvent
 import net.dv8tion.jda.api.utils.FileUpload
 import java.awt.Color
@@ -21,45 +20,6 @@ object Utils {
 
     private inline val logger get() = BOT.logger
 
-    fun reply(text: String, event: Any, ephemeral: Boolean = false) {
-        doWhen(event, {
-            it.message.messageReply(text)
-        }, {
-            it.reply(text).setEphemeral(ephemeral).queue()
-        })
-    }
-
-    fun reply(embed: MessageEmbed, event: Any, ephemeral: Boolean = false) {
-        doWhen(event, {
-            it.message.messageReply(embed)
-        }, {
-            it.replyEmbeds(embed).setEphemeral(ephemeral).queue()
-        })
-    }
-
-    fun userError(text: String, event: Any, ephemeral: Boolean = true) {
-        doWhen(event, {
-            it.message.messageReply("❌ $text")
-        }, {
-            it.reply("❌ $text").setEphemeral(ephemeral).queue()
-        })
-    }
-
-    fun sendError(text: String, event: Any, ephemeral: Boolean = true) {
-        doWhen(event, {
-            it.message.messageReply("❌ $text")
-        }, {
-            it.reply("❌ $text").setEphemeral(ephemeral).queue()
-        })
-
-        logAction("Error: $text", event)
-    }
-
-    fun MessageReceivedEvent.replyWithConsumer(text: String, consumer: (MessageReceivedEvent) -> Unit) {
-        BotMessageHandler.log(text, consumer)
-        reply(text, this)
-    }
-
     fun Message.messageDelete() {
         delete().queue()
     }
@@ -100,25 +60,7 @@ object Utils {
         BOT.jda.getTextChannelById(BOT.config.botCommandChannelId)?.messageSend(text, instantly)
     }
 
-    fun logAction(action: String, event: Any, raw: Boolean = false) {
-        val author = when (event) {
-            is MessageReceivedEvent -> event.author
-            is SlashCommandInteractionEvent -> event.user
-            else -> throw IllegalArgumentException("Unknown event type")
-        }
-
-        val member = when (event) {
-            is MessageReceivedEvent -> event.member
-            is SlashCommandInteractionEvent -> event.member
-            else -> throw IllegalArgumentException("Unknown event type")
-        }
-
-        val channel = when (event) {
-            is MessageReceivedEvent -> event.channel
-            is SlashCommandInteractionEvent -> event.channel
-            else -> throw IllegalArgumentException("Unknown event type")
-        }
-
+    fun CommandEvent.logAction(action: String, raw: Boolean = false) {
         if (raw) {
             logger.info(action)
             return
@@ -127,41 +69,20 @@ object Utils {
         val name = author.name
         val id = author.id
         val nickString = member?.nickname?.takeIf { it != "null" }?.let { " (`$it`)" } ?: ""
-        val isFromGuild =
-            (event as? MessageReceivedEvent)?.isFromGuild ?: (event as? SlashCommandInteractionEvent)?.isFromGuild
-            ?: false
+        val isFromGuild = isFromGuild
         val channelSuffix = if (isFromGuild) " in channel '${channel.name}'" else ""
 
         logger.info("$id/$name$nickString $action$channelSuffix")
     }
 
-    fun hasAdminPermissions(event: Any): Boolean {
-        val member = doWhen(
-            event,
-            { it.member },
-            { it.member }
-        ) as Member
+    fun CommandEvent.hasAdminPermissions(): Boolean {
+        val member = member ?: return false
 
         val allowedRoleIds = BOT.config.editPermissionRoleIds.values
         return !member.roles.none { it.id in allowedRoleIds }
     }
 
-    fun <T> doWhen(
-        event: Any,
-        consumer: (MessageReceivedEvent) -> T?,
-        consumer2: (SlashCommandInteractionEvent) -> T?
-    ): T? {
-        return when (event) {
-            is MessageReceivedEvent -> consumer(event)
-            is SlashCommandInteractionEvent -> consumer2(event)
-            else -> null
-        }
-    }
-
-    fun inBotCommandChannel(event: Any): Boolean {
-        val id = doWhen(event, { it.channel.id }, { it.channel.id })
-        return id == BOT.config.botCommandChannelId
-    }
+    fun CommandEvent.inBotCommandChannel(): Boolean = channel.id == BOT.config.botCommandChannelId
 
     fun runDelayed(duration: Duration, consumer: () -> Unit) {
         Thread {
diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/BaseCommand.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/BaseCommand.kt
index 13257dd..a8051bf 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/BaseCommand.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/BaseCommand.kt
@@ -1,7 +1,6 @@
 package at.hannibal2.skyhanni.discord.command
 
 import at.hannibal2.skyhanni.discord.Option
-import at.hannibal2.skyhanni.discord.Utils.userError
 
 abstract class BaseCommand {
 
@@ -15,10 +14,10 @@ abstract class BaseCommand {
 
     protected open val aliases: List<String> = emptyList()
 
-    abstract fun execute(args: List<String>, event: Any)
+    abstract fun CommandEvent.execute(args: List<String>)
 
-    protected fun wrongUsage(args: String, event: Any) {
-        userError("Usage: `!$name $args`", event)
+    protected fun CommandEvent.wrongUsage(args: String) {
+        userError("Usage: `!$name $args`")
     }
 
     fun getAllNames(): List<String> = aliases + name
diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/CommandEvent.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/CommandEvent.kt
new file mode 100644
index 0000000..cf2503e
--- /dev/null
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/CommandEvent.kt
@@ -0,0 +1,114 @@
+package at.hannibal2.skyhanni.discord.command
+
+import at.hannibal2.skyhanni.discord.BotMessageHandler
+import at.hannibal2.skyhanni.discord.Utils.messageReply
+import net.dv8tion.jda.api.entities.Member
+import net.dv8tion.jda.api.entities.Message
+import net.dv8tion.jda.api.entities.MessageEmbed
+import net.dv8tion.jda.api.entities.User
+import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent
+
+abstract class CommandEvent {
+
+    abstract val member: Member?
+
+    abstract val author: User
+
+    abstract val channel: MessageChannel
+
+    abstract val message: Message?
+
+    abstract val isFromGuild: Boolean
+
+    abstract fun reply(text: String, ephemeral: Boolean = false)
+
+    abstract fun reply(embed: MessageEmbed, ephemeral: Boolean = false)
+
+    abstract fun userError(text: String)
+
+    abstract fun sendError(text: String)
+
+    fun replyWithConsumer(text: String, consumer: (MessageReceivedEvent) -> Unit) {
+        BotMessageHandler.log(text, consumer)
+        reply(text)
+    }
+
+    fun <T> doWhen(
+        isMessage: (MessageReceivedEvent) -> T?,
+        isSlashCommand: (SlashCommandInteractionEvent) -> T?
+    ): T? {
+        return when (this) {
+            is MessageEvent -> isMessage(this.event)
+            is SlashCommandEvent -> isSlashCommand(this.event)
+            else -> null
+        }
+    }
+}
+
+class MessageEvent(val event: MessageReceivedEvent) : CommandEvent() {
+    override val member: Member?
+        get() = event.member
+    override val author: User
+        get() = event.author
+    override val channel: MessageChannel
+        get() = event.channel
+    override val message: Message
+        get() = event.message
+    override val isFromGuild: Boolean
+        get() = event.isFromGuild
+
+    override fun reply(text: String, ephemeral: Boolean) {
+        event.message.messageReply(text)
+    }
+
+    override fun reply(embed: MessageEmbed, ephemeral: Boolean) {
+        event.message.messageReply(embed)
+    }
+
+    override fun userError(text: String) {
+        event.message.messageReply("❌ $text")
+    }
+
+    override fun sendError(text: String) {
+        event.message.messageReply("❌ An error occurred: $text")
+    }
+}
+
+class SlashCommandEvent(val event: SlashCommandInteractionEvent) : CommandEvent() {
+    override val member: Member?
+        get() = event.member
+    override val author: User
+        get() = event.user
+    override val channel: MessageChannel
+        get() = event.channel
+    override val message: Message?
+        get() = null
+    override val isFromGuild: Boolean
+        get() = event.isFromGuild
+
+    fun reply(text: String) {
+        reply(text, false)
+    }
+
+    fun reply(embed: MessageEmbed) {
+        reply(embed, false)
+    }
+
+    override fun reply(text: String, ephemeral: Boolean) {
+        event.reply(text).setEphemeral(ephemeral).queue()
+    }
+
+    override fun reply(embed: MessageEmbed, ephemeral: Boolean) {
+        event.replyEmbeds(embed).setEphemeral(ephemeral).queue()
+    }
+
+    override fun userError(text: String) {
+        reply("❌ $text", ephemeral = true)
+    }
+
+    override fun sendError(text: String) {
+        reply("❌ An error occurred: $text", ephemeral = true)
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/HelpCommand.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/HelpCommand.kt
index cae0b1d..bbccfd4 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/HelpCommand.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/HelpCommand.kt
@@ -1,15 +1,12 @@
 package at.hannibal2.skyhanni.discord.command
 
 import at.hannibal2.skyhanni.discord.BOT
+import at.hannibal2.skyhanni.discord.PLEADING_FACE
 import at.hannibal2.skyhanni.discord.CommandListener
 import at.hannibal2.skyhanni.discord.Option
-import at.hannibal2.skyhanni.discord.PLEADING_FACE
-import at.hannibal2.skyhanni.discord.Utils.doWhen
 import at.hannibal2.skyhanni.discord.Utils.hasAdminPermissions
 import at.hannibal2.skyhanni.discord.Utils.inBotCommandChannel
 import at.hannibal2.skyhanni.discord.Utils.messageDelete
-import at.hannibal2.skyhanni.discord.Utils.reply
-import at.hannibal2.skyhanni.discord.Utils.replyWithConsumer
 import at.hannibal2.skyhanni.discord.Utils.runDelayed
 import net.dv8tion.jda.api.EmbedBuilder
 import net.dv8tion.jda.api.entities.MessageEmbed
@@ -24,65 +21,54 @@ object HelpCommand : BaseCommand() {
 
     override val userCommand: Boolean = true
 
-    override fun execute(args: List<String>, event: Any) {
+    override fun CommandEvent.execute(args: List<String>) {
         if (args.size > 1) {
-            reply("Usage: !help <command>", event)
+            reply("Usage: !help <command>")
             return
         }
 
         val command = doWhen(
-            event,
-            { if (args.isEmpty()) null else args.first().lowercase() },
-            { it.getOption("command")?.asString }
+            isMessage = { if (args.isEmpty()) null else args.first().lowercase() },
+            isSlashCommand = { it.getOption("command")?.asString }
         )
 
         if (command != null) {
-            sendUsageReply(command, event)
+            sendUsageReply(command)
         } else {
-            val commands = if (hasAdminPermissions(event) && inBotCommandChannel(event)) {
+            val commands = if (hasAdminPermissions() && inBotCommandChannel()) {
                 CommandListener.commands
             } else {
                 CommandListener.commands.filter { it.userCommand }
             }
             val list = commands.joinToString(", !", prefix = "!") { it.name }
-            reply("Supported commands: $list", event)
+            reply("Supported commands: $list")
 
-            if (hasAdminPermissions(event) && !inBotCommandChannel(event)) {
+            if (hasAdminPermissions() && !inBotCommandChannel()) {
                 val id = BOT.config.botCommandChannelId
                 val botCommandChannel = "https://discord.com/channels/$id/$id"
 
-                doWhen(
-                    event, {
-                        it.replyWithConsumer("You wanna see the cool admin only commands? visit $botCommandChannel") { consumer ->
-                            runDelayed(3.seconds) {
-                                consumer.message.messageDelete()
-                            }
-                        }
-                    }, {
-                        it.channel.sendMessage("You wanna see the cool admin only commands? visit $botCommandChannel")
-                            .queue {
-                                runDelayed(3.seconds) {
-                                    it.channel.deleteMessageById(it.id).queue()
-                                }
-                            }
+                replyWithConsumer("You wanna see the cool admin only commands? visit $botCommandChannel") {
+                    runDelayed(3.seconds) {
+                        val message = message ?: return@runDelayed
+                        message.messageDelete()
                     }
-                )
+                }
             }
         }
     }
 
-    fun sendUsageReply(commandName: String, event: Any) {
+    fun CommandEvent.sendUsageReply(commandName: String) {
         val command = CommandListener.getCommand(commandName) ?: run {
-            reply("Unknown command `!$commandName` $PLEADING_FACE", event)
+            reply("Unknown command `!$commandName` $PLEADING_FACE")
             return
         }
 
-        if (!command.userCommand && !hasAdminPermissions(event)) {
-            reply("No permissions for command `!$commandName` $PLEADING_FACE", event)
+        if (!command.userCommand && !hasAdminPermissions()) {
+            reply("No permissions for command `!$commandName` $PLEADING_FACE")
             return
         }
 
-        reply(createHelpEmbed(commandName), event)
+        reply(createHelpEmbed(commandName))
     }
 
     private fun BaseCommand.createHelpEmbed(commandName: String): MessageEmbed {
diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/PullRequestCommand.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/PullRequestCommand.kt
index 244eb29..083ba37 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/PullRequestCommand.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/PullRequestCommand.kt
@@ -5,26 +5,20 @@ import at.hannibal2.skyhanni.discord.Option
 import at.hannibal2.skyhanni.discord.PLEADING_FACE
 import at.hannibal2.skyhanni.discord.SimpleTimeMark
 import at.hannibal2.skyhanni.discord.SimpleTimeMark.Companion.asTimeMark
-import at.hannibal2.skyhanni.discord.Utils
 import at.hannibal2.skyhanni.discord.Utils.createParentDirIfNotExist
-import at.hannibal2.skyhanni.discord.Utils.doWhen
 import at.hannibal2.skyhanni.discord.Utils.embed
 import at.hannibal2.skyhanni.discord.Utils.format
 import at.hannibal2.skyhanni.discord.Utils.linkTo
 import at.hannibal2.skyhanni.discord.Utils.logAction
 import at.hannibal2.skyhanni.discord.Utils.messageDelete
-import at.hannibal2.skyhanni.discord.Utils.reply
-import at.hannibal2.skyhanni.discord.Utils.replyWithConsumer
 import at.hannibal2.skyhanni.discord.Utils.runDelayed
 import at.hannibal2.skyhanni.discord.Utils.timeExecution
 import at.hannibal2.skyhanni.discord.Utils.unzipFile
 import at.hannibal2.skyhanni.discord.Utils.uploadFile
-import at.hannibal2.skyhanni.discord.Utils.userError
 import at.hannibal2.skyhanni.discord.github.GitHubClient
 import at.hannibal2.skyhanni.discord.json.discord.PullRequestJson
 import at.hannibal2.skyhanni.discord.json.discord.Status
-import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
-import net.dv8tion.jda.api.events.message.MessageReceivedEvent
+import net.dv8tion.jda.api.entities.channel.unions.MessageChannelUnion
 import java.awt.Color
 import java.io.File
 import java.time.Instant
@@ -52,40 +46,40 @@ object PullRequestCommand : BaseCommand() {
         Regex("https://github\\.com/[\\w.]+/[\\w.]+/actions/runs/(?<RunId>\\d+)/job/(?<JobId>\\d+)")
     private val pullRequestPattern = "$BASE/pull/(?<pr>\\d+)".toPattern()
 
-    override fun execute(args: List<String>, event: Any) {
-        val prNumber = doWhen(event, {
-            if (args.size != 1) {
-                wrongUsage("<number>", event)
-                return@doWhen null
-            }
+    override fun CommandEvent.execute(args: List<String>) {
+        if (args.isNotEmpty() && args.size != 1) {
+            wrongUsage("<number>")
+            return
+        }
 
-            val first = args.first()
-            first.toIntOrNull() ?: run {
-                userError("Unknown number $PLEADING_FACE ($first})", event)
-                null
+        val prNumber = doWhen(
+            isMessage = {
+                val first = args.first()
+                first.toIntOrNull() ?: run {
+                    userError("Unknown number $PLEADING_FACE ($first})")
+                    null
+                }
+            },
+            isSlashCommand = {
+                it.getOption("number")?.asInt
             }
-        }, {
-            it.getOption("number")?.asInt
-        }) ?: return
+        ) ?: return
 
         if (prNumber < 1) {
-            userError("PR number needs to be positive $PLEADING_FACE", event, ephemeral = true)
+            userError("PR number needs to be positive $PLEADING_FACE")
             return
         }
 
-        loadPrInfos(prNumber, event)
+        loadPrInfos(prNumber)
     }
 
-    private fun loadPrInfos(prNumber: Int, event: Any) {
-        when (event) {
-            is MessageReceivedEvent -> logAction("loads pr infos for #$prNumber", event)
-            is SlashCommandInteractionEvent -> logAction("loads pr infos for #$prNumber", event)
-        }
+    private fun CommandEvent.loadPrInfos(prNumber: Int) {
+        logAction("loads pr infos for #$prNumber")
 
         val prLink = "$BASE/pull/$prNumber"
 
         val pr =
-            runCatching { github.findPullRequest(prNumber) }.getOrElse { handlePrError(prNumber, event, it); return }
+            runCatching { github.findPullRequest(prNumber) }.getOrElse { handlePrError(prNumber, it); return }
                 ?: return
 
         val head = pr.head
@@ -102,14 +96,13 @@ object PullRequestCommand : BaseCommand() {
                     embedTitle,
                     "$title$time \nArtifact does not exist $PLEADING_FACE (expired or first PR of contributor)",
                     readColor(pr)
-                ),
-                event
+                )
             )
             return
         }
 
         if (job.startedAt?.let { toTimeMark(it).passedSince() > 90.days } == true) {
-            reply(embed(embedTitle, "$title$time \nArtifact has expired $PLEADING_FACE", readColor(pr)), event)
+            reply(embed(embedTitle, "$title$time \nArtifact has expired $PLEADING_FACE", readColor(pr)))
             return
         }
 
@@ -121,7 +114,7 @@ object PullRequestCommand : BaseCommand() {
                 Status.WAITING to "Run is waiting $PLEADING_FACE",
                 Status.PENDING to "Run is pending $PLEADING_FACE"
             )[job.status] ?: ""
-            reply(embed(embedTitle, "$title$time \n$statusText", readColor(pr)), event)
+            reply(embed(embedTitle, "$title$time \n$statusText", readColor(pr)))
             return
         }
 
@@ -133,16 +126,16 @@ object PullRequestCommand : BaseCommand() {
                 "Nightly".linkTo(nightlyLink)
             } (unofficial)\n> (updated ${passedSince(job.completedAt ?: "")})"
 
-        reply(embed(embedTitle, "$title$time$artifactDisplay", readColor(pr)), event)
+        reply(embed(embedTitle, "$title$time$artifactDisplay", readColor(pr)))
     }
 
-    private fun handlePrError(prNumber: Int, event: Any, e: Throwable) {
+    private fun CommandEvent.handlePrError(prNumber: Int, e: Throwable) {
         if (e is IllegalStateException && e.message?.contains(" code:404 ") == true) {
             val text = "This pull request does not yet exist or is an ${"issue".linkTo("$BASE/issues/$prNumber")}"
-            reply(embed("Not found $PLEADING_FACE", text, Color.red), event, ephemeral = true)
+            reply(embed("Not found $PLEADING_FACE", text, Color.red), ephemeral = true)
             return
         }
-        reply("Could not load pull request infos for #$prNumber: ${e.message}", event, ephemeral = true)
+        reply("Could not load pull request infos for #$prNumber: ${e.message}", ephemeral = true)
     }
 
     // Colors picked from GitHub
@@ -160,43 +153,43 @@ object PullRequestCommand : BaseCommand() {
     private fun passedSince(stringTime: String): String = "<t:${parseToUnixTime(stringTime)}:R>"
 
     @Suppress("unused") // TODO implement once we can upload the file
-    private fun MessageReceivedEvent.pullRequestArtifactCommand(args: List<String>) {
+    private fun CommandEvent.pullRequestArtifactCommand(args: List<String>) {
         if (args.size != 2) {
-            reply("Usage: `!prupload <number>`", this)
+            reply("Usage: `!prupload <number>`")
             return
         }
         val prNumber = args[1].toIntOrNull() ?: run {
-            reply("unknwon number $PLEADING_FACE (${args[1]})", this)
+            reply("unknwon number $PLEADING_FACE (${args[1]})")
             return
         }
 
         val prLink = "$BASE/pull/$prNumber"
-        reply("Looking for pr <$prLink..", this)
+        reply("Looking for pr <$prLink..")
 
         val pr = github.findPullRequest(prNumber) ?: run {
-            reply("pr is null!", this)
+            reply("pr is null!")
             return
         }
         val head = pr.head
-        reply("found pr `${pr.title}` (from `${head.user.login}`)", this)
+        reply("found pr `${pr.title}` (from `${head.user.login}`)")
 
-        reply("looking for artifact ..", this)
+        reply("looking for artifact ..")
         val lastCommit = head.sha
         val artifact = github.findArtifact(lastCommit) ?: run {
-            reply("artifact is null!", this)
+            reply("artifact is null!")
             return
         }
-        reply("found artifact", this)
+        reply("found artifact")
 
         val artifactId = artifact.id
         val fileRaw = File("temp/downloads/artifact-$artifactId-raw")
         fileRaw.createParentDirIfNotExist()
         val fileUnzipped = File("temp/downloads/artifact-$artifactId-unzipped")
-        reply("Downloading artifact ..", this)
+        reply("Downloading artifact ..")
         val (_, downloadTime) = timeExecution {
             github.downloadArtifact(artifactId, fileRaw)
         }
-        reply("artifact downnloaded in ${downloadTime.format()}", this)
+        reply("artifact downnloaded in ${downloadTime.format()}")
 
         unzipFile(fileRaw, fileUnzipped)
         fileRaw.delete()
@@ -204,31 +197,31 @@ object PullRequestCommand : BaseCommand() {
         val displayUrl = "$BASE/actions/runs/$artifactId?pr=$prNumber"
 
         val modJar = findJarFile(fileUnzipped) ?: run {
-            reply("mod jar not found!", this)
+            reply("mod jar not found!")
             return
         }
 
-        reply("start uploading..", this)
+        reply("start uploading..")
         val (_, uploadTime) = timeExecution {
-            channel.uploadFile(modJar, "here is the jar from <$displayUrl>")
+            (channel as MessageChannelUnion).uploadFile(modJar, "here is the jar from <$displayUrl>")
         }
-        reply("Mod jar uploaded in ${uploadTime.format()}", this)
+        reply("Mod jar uploaded in ${uploadTime.format()}")
     }
 
     private fun findJarFile(directory: File): File? {
         return directory.walkTopDown().firstOrNull { it.isFile && it.name.startsWith("SkyHanni-") }
     }
 
-    fun isPullRequest(event: MessageReceivedEvent, message: String): Boolean {
+    fun MessageEvent.isPullRequest(message: String): Boolean {
         val matcher = pullRequestPattern.matcher(message)
         if (!matcher.matches()) return false
         val pr = matcher.group("pr")?.toIntOrNull() ?: return false
-        event.replyWithConsumer("Next time just type `!pr $pr` $PLEADING_FACE") { consumer ->
+        replyWithConsumer("Next time just type `!pr $pr` $PLEADING_FACE") { consumer ->
             runDelayed(10.seconds) {
                 consumer.message.messageDelete()
             }
         }
-        loadPrInfos(pr, this)
+        loadPrInfos(pr)
         return true
     }
 }
@@ -250,7 +243,7 @@ object PullRequestCommand : BaseCommand() {
 //                return
 //            }
 //
-//            loadPrInfos(prNumber, this)
+//            loadPrInfos(prNumber)
 //        }
 //    }
 //}
\ No newline at end of file
diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/ServerCommands.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/ServerCommands.kt
index 14dcb80..0122a83 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/ServerCommands.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/ServerCommands.kt
@@ -1,17 +1,11 @@
 package at.hannibal2.skyhanni.discord.command
 
-import at.hannibal2.skyhanni.discord.BOT
-import at.hannibal2.skyhanni.discord.Option
-import at.hannibal2.skyhanni.discord.Utils
-import at.hannibal2.skyhanni.discord.Utils.doWhen
+import at.hannibal2.skyhanni.discord.*
 import at.hannibal2.skyhanni.discord.Utils.logAction
-import at.hannibal2.skyhanni.discord.Utils.reply
 import at.hannibal2.skyhanni.discord.Utils.sendMessageToBotChannel
-import at.hannibal2.skyhanni.discord.Utils.userError
 import at.hannibal2.skyhanni.discord.github.GitHubClient
 import com.google.gson.Gson
 import com.google.gson.reflect.TypeToken
-import net.dv8tion.jda.api.events.message.MessageReceivedEvent
 import net.dv8tion.jda.api.interactions.commands.OptionType
 import kotlin.time.Duration.Companion.milliseconds
 
@@ -137,15 +131,15 @@ object ServerCommands {
 
     private fun getServerByInviteUrl(url: String): Server? = servers.firstOrNull { it.invite == url }
 
-    fun isKnownServerUrl(event: MessageReceivedEvent, message: String): Boolean {
+    fun MessageEvent.isKnownServerUrl(message: String): Boolean {
         val server = getServerByInviteUrl(message) ?: run {
             if (isDiscordInvite(message)) {
-                logAction("sends unknown discord invite '$message'", event)
+                logAction("sends unknown discord invite '$message'")
             }
             return false
         }
 
-        reply(server.print(tutorial = true), event)
+        reply(server.print(tutorial = true))
         return true
     }
 
@@ -176,26 +170,27 @@ class ServerCommand : BaseCommand() {
     )
     override val userCommand: Boolean = true
 
-    override fun execute(args: List<String>, event: Any) {
-        val keyword = doWhen(event, {
-            if (args.size !in 1..2) {
-                wrongUsage("<keyword>", event)
-            }
-
-            args.first()
-        }, {
-            it.getOption("keyword")?.asString
-        }) ?: return
+    override fun CommandEvent.execute(args: List<String>) {
+        if (args.isNotEmpty() && args.size !in 1..2) {
+            wrongUsage("<keyword>")
+            return
+        }
+        val keyword = doWhen(
+            isMessage = { args.first() }, isSlashCommand = { it.getOption("keyword")?.asString }
+        ) ?: return
 
+        val debug = doWhen(
+            isMessage = { args.getOrNull(1) == "-d" },
+            isSlashCommand = { it.getOption("debug")?.asBoolean == true }
+        ) ?: false
 
-        val debug = doWhen(event, { args.getOrNull(1) == "-d" }, { it.getOption("debug")?.asBoolean == true }) ?: false
         val server = ServerCommands.getServer(keyword.lowercase())
         if (server == null) {
-            userError("Server with keyword '$keyword' not found.", event, ephemeral = true)
+            userError("Server with keyword '$keyword' not found.")
             return
         }
-        if (debug) reply(server.printDebug(), event)
-        else reply(server.print(), event)
+        if (debug) reply(server.printDebug())
+        else reply(server.print())
     }
 }
 
@@ -205,13 +200,12 @@ class ServerUpdate : BaseCommand() {
     override val description: String = "Updates the server list."
     override val aliases: List<String> = listOf("updateservers")
 
-    override fun execute(args: List<String>, event: Any) {
+    override fun CommandEvent.execute(args: List<String>) {
         ServerCommands.loadServers(startup = false)
         reply(
-            "Updated server list from [GitHub](<https://github.com/SkyHanniStudios/DiscordBot/blob/master/data/discord_servers.json>).",
-            event
+            "Updated server list from [GitHub](<https://github.com/SkyHanniStudios/DiscordBot/blob/master/data/discord_servers.json>)."
         )
-        logAction("updated server list from github", event)
+        logAction("updated server list from github")
     }
 }
 
@@ -221,7 +215,7 @@ class ServerList : BaseCommand() {
     override val description: String = "Displays all servers in the database."
     override val aliases: List<String> = listOf("servers")
 
-    override fun execute(args: List<String>, event: Any) {
-        reply(ServerCommands.listServers(), event, ephemeral = true)
+    override fun CommandEvent.execute(args: List<String>) {
+        reply(ServerCommands.listServers(), ephemeral = true)
     }
 }
\ No newline at end of file
diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/TagCommands.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/TagCommands.kt
index 0b5b241..8bca5f4 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/TagCommands.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/TagCommands.kt
@@ -1,24 +1,16 @@
 package at.hannibal2.skyhanni.discord.command
 
-import at.hannibal2.skyhanni.discord.CommandListener
-import at.hannibal2.skyhanni.discord.Database
-import at.hannibal2.skyhanni.discord.Option
-import at.hannibal2.skyhanni.discord.PLEADING_FACE
-import at.hannibal2.skyhanni.discord.Utils.doWhen
+import at.hannibal2.skyhanni.discord.*
 import at.hannibal2.skyhanni.discord.Utils.logAction
 import at.hannibal2.skyhanni.discord.Utils.messageDelete
 import at.hannibal2.skyhanni.discord.Utils.messageDeleteAndThen
-import at.hannibal2.skyhanni.discord.Utils.reply
 import at.hannibal2.skyhanni.discord.Utils.replyWithConsumer
 import at.hannibal2.skyhanni.discord.Utils.runDelayed
-import at.hannibal2.skyhanni.discord.Utils.sendError
 import at.hannibal2.skyhanni.discord.Utils.sendMessageWithConsumer
-import at.hannibal2.skyhanni.discord.Utils.userError
 import at.hannibal2.skyhanni.discord.command.TagCommands.addLastMessage
 import at.hannibal2.skyhanni.discord.command.TagCommands.lastMessages
 import at.hannibal2.skyhanni.discord.command.TagCommands.lastTouchedTag
 import net.dv8tion.jda.api.entities.Message
-import net.dv8tion.jda.api.events.message.MessageReceivedEvent
 import kotlin.time.Duration.Companion.seconds
 
 object TagCommands {
@@ -31,7 +23,7 @@ object TagCommands {
         lastMessages.getOrPut(author) { mutableListOf() }.add(message)
     }
 
-    fun handleTag(event: MessageReceivedEvent): Boolean {
+    fun MessageEvent.handleTag(): Boolean {
         val message = event.message
         var keyword = message.contentRaw.substring(1)
         var deleting = false
@@ -40,28 +32,28 @@ object TagCommands {
             deleting = true
         }
         val response = Database.getResponse(keyword) ?: run {
-            reply("Unknown command $PLEADING_FACE Type `!help` for help.", event)
+            reply("Unknown command $PLEADING_FACE Type `!help` for help.")
             return false
         }
 
         val author = message.author.id
         lastTouchedTag[author] = keyword
         message.referencedMessage?.let {
-            logAction("used keyword '$keyword' (with reply)", event)
+            logAction("used keyword '$keyword' (with reply)")
             message.messageDelete()
             it.replyWithConsumer(response) { consumer ->
                 addLastMessage(author, consumer.message)
             }
         } ?: run {
             if (deleting) {
-                logAction("used keyword '$keyword' (with delete)", event)
+                logAction("used keyword '$keyword' (with delete)")
                 message.messageDeleteAndThen {
                     event.channel.sendMessageWithConsumer(response) { consumer ->
                         addLastMessage(author, consumer.message)
                     }
                 }
             } else {
-                logAction("used keyword '$keyword'", event)
+                logAction("used keyword '$keyword'")
                 addLastMessage(author, message)
                 message.replyWithConsumer(response) { consumer ->
                     addLastMessage(author, consumer.message)
@@ -79,10 +71,10 @@ class TagList : BaseCommand() {
     override val aliases = listOf("tags")
     override val userCommand: Boolean = true
 
-    override fun execute(args: List<String>, event: Any) {
+    override fun CommandEvent.execute(args: List<String>) {
         val list = Database.listKeywords()
         val keywords = list.joinToString(", !", prefix = "!")
-        reply(if (list.isNotEmpty()) "📌 All ${list.size} keywords: $keywords" else "No keywords set.", event)
+        reply(if (list.isNotEmpty()) "📌 All ${list.size} keywords: $keywords" else "No keywords set.")
     }
 }
 
@@ -96,40 +88,38 @@ class TagEdit : BaseCommand() {
     )
     override val aliases = listOf("tagchange")
 
-    override fun execute(args: List<String>, event: Any) {
-        val keyword = doWhen(event,
-            {
-                if (args.size < 2) {
-                    wrongUsage("<keyword> <response>", event)
-                    return@doWhen null
-                }
-
-                args.first()
-            },
-            { it.getOption("keyword")?.asString }
+    override fun CommandEvent.execute(args: List<String>) {
+        if (args.isNotEmpty() && args.size < 2) {
+            wrongUsage("<keyword> <response>")
+            return
+        }
+        val keyword = doWhen(
+            isMessage = { args.first() }, isSlashCommand = { it.getOption("keyword")?.asString }
         ) ?: return
 
-        val response =
-            doWhen(event, { args.drop(1).joinToString(" ") }, { it.getOption("response")?.asString }) ?: return
+        val response = doWhen(
+            isMessage = { args.drop(1).joinToString(" ") },
+            isSlashCommand = { it.getOption("response")?.asString }
+        ) ?: return
 
         val oldResponse = Database.getResponse(keyword)
         if (oldResponse == null) {
-            userError("Keyword doesn't exist! Use `!tagadd` instead.", event, ephemeral = true)
+            userError("Keyword doesn't exist! Use `!tagadd` instead.")
             return
         }
         if (Database.addKeyword(keyword, response)) {
-            doWhen(event, { it.message.messageDelete() }, {})
+            doWhen(isMessage = { it.message.messageDelete() }, isSlashCommand = {})
 
-            val id = doWhen(event, { it.author.id }, { it.user.id }).toString()
+            val id = author.id
 
-            reply("✅ Keyword '$keyword' edited by <@$id>:", event)
-            doWhen(event, { reply(response, it) }, { it.channel.sendMessage(response).queue() })
-            logAction("edited keyword '$keyword'", event)
-            logAction("old response: '$oldResponse'", event, raw = true)
-            logAction("new response: '$response'", event, raw = true)
+            reply("✅ Keyword '$keyword' edited by <@$id>:")
+            doWhen(isMessage = { reply(response) }, isSlashCommand = { it.channel.sendMessage(response).queue() })
+            logAction("edited keyword '$keyword'")
+            logAction("old response: '$oldResponse'", raw = true)
+            logAction("new response: '$response'", raw = true)
             lastTouchedTag[id] = keyword
         } else {
-            sendError("❌ Failed to edit keyword.", event, ephemeral = true)
+            sendError("❌ Failed to edit keyword.")
         }
     }
 }
@@ -139,20 +129,18 @@ class TagEditLast : BaseCommand() {
     override val name = "tageditlast"
     override val description = "Show info on how to edit the last tag used."
 
-    override fun execute(args: List<String>, event: Any) {
-        val id = doWhen(event, { it.author.id }, { it.user.id }).toString()
+    override fun CommandEvent.execute(args: List<String>) {
+        val id = author.id
 
         val lastTag = lastTouchedTag[id] ?: run {
-            return userError("No last tag found $PLEADING_FACE", event, ephemeral = true)
+            return userError("No last tag found $PLEADING_FACE")
         }
         val response = Database.getResponse(lastTag) ?: run {
             return sendError(
-                "Last tag `$lastTag` got deleted, this should not happen, therefore we ping <@239858538959077376>",
-                event,
-                ephemeral = true
+                "Last tag `$lastTag` got deleted, this should not happen, therefore we ping <@239858538959077376>"
             )
         }
-        reply("```!tagedit $lastTag $response```", event, ephemeral = true)
+        reply("```!tagedit $lastTag $response```")
     }
 }
 
@@ -166,14 +154,12 @@ class TagAdd : BaseCommand() {
     )
     override val aliases = listOf("tagcreate")
 
-    override fun execute(args: List<String>, event: Any) {
-        val keyword = doWhen(event, {
-            if (args.size < 2) {
-                wrongUsage("<keyword> <response>", event)
-                return@doWhen null
-            }
-            args.first()
-        }, {
+    override fun CommandEvent.execute(args: List<String>) {
+        if (args.isNotEmpty() && args.size < 2) {
+            wrongUsage("<keyword> <response>")
+            return
+        }
+        val keyword = doWhen(isMessage = { args.first() }, isSlashCommand = {
             it.getOption("keyword")?.asString
         }) ?: return
 
@@ -181,27 +167,26 @@ class TagAdd : BaseCommand() {
         if (CommandListener.existsCommand(keyword)) {
             return userError(
                 "Can not create keyword `!$keyword`. There is already a command with that name",
-                event,
-                ephemeral = true
             )
         }
-        val response =
-            doWhen(event, { args.drop(1).joinToString(" ") }, { it.getOption("response")?.asString }) ?: return
+        val response = doWhen(
+            isMessage = { args.drop(1).joinToString(" ") },
+            isSlashCommand = { it.getOption("response")?.asString }
+        ) ?: return
 
         if (Database.containsKeyword(keyword)) {
-            return userError("Keyword already exists. Use `!tagedit` instead.", event, ephemeral = true)
+            return userError("Keyword already exists. Use `!tagedit` instead.")
         }
         if (Database.addKeyword(keyword, response)) {
-            doWhen(event, { it.message.messageDelete() }, {})
-            val author = doWhen(event, { it.author }, { it.user }) ?: return
+            doWhen(isMessage = { it.message.messageDelete() }, isSlashCommand = {})
 
-            reply("✅ Keyword '$keyword' added by ${author.asMention}:", event)
-            doWhen(event, { reply(response, event) }, { it.channel.sendMessage(response).queue() })
-            logAction("added keyword '$keyword'", event)
-            logAction("response: '$response'", event, raw = true)
+            reply("✅ Keyword '$keyword' added by ${author.asMention}:")
+            doWhen(isMessage = { reply(response) }, isSlashCommand = { it.channel.sendMessage(response).queue() })
+            logAction("added keyword '$keyword'")
+            logAction("response: '$response'", raw = true)
             lastTouchedTag[author.id] = keyword
         } else {
-            sendError("❌ Failed to add keyword.", event, ephemeral = true)
+            sendError("❌ Failed to add keyword.")
         }
     }
 }
@@ -215,26 +200,25 @@ class TagDelete : BaseCommand() {
     )
     override val aliases: List<String> = listOf("tagremove")
 
-    override fun execute(args: List<String>, event: Any) {
-        val keyword = doWhen(event, {
-            if (args.isEmpty()) {
-                wrongUsage("<keyword>", event)
-                return@doWhen null
-            }
-
-            args.first()
-        }, { it.getOption("keyword")?.asString }) ?: return
+    override fun CommandEvent.execute(args: List<String>) {
+        if (this is MessageEvent && args.isEmpty()) {
+            wrongUsage("<keyword>")
+            return
+        }
+        val keyword = doWhen(
+            isMessage = { args.first() }, isSlashCommand = { it.getOption("keyword")?.asString }
+        ) ?: return
 
         val oldResponse = Database.getResponse(keyword)
 
         if (Database.deleteKeyword(keyword)) {
-            reply("🗑️ Keyword '$keyword' deleted!", event)
-            logAction("deleted keyword '$keyword'", event)
-            logAction("response was: '$oldResponse'", event, raw = true)
-            val id = doWhen(event, { it.author.id }, { it.user.id })
+            reply("🗑️ Keyword '$keyword' deleted!")
+            logAction("deleted keyword '$keyword'")
+            logAction("response was: '$oldResponse'", raw = true)
+            val id = author.id
             lastTouchedTag.remove(id)
         } else {
-            userError("Keyword '$keyword' not found.", event, ephemeral = true)
+            userError("Keyword '$keyword' not found.")
         }
     }
 }
@@ -246,24 +230,27 @@ object TagUndo : BaseCommand() {
     override val userCommand: Boolean = true
     override val aliases: List<String> = listOf("undo")
 
-    override fun execute(args: List<String>, event: Any) {
-        val author = doWhen(event, { it.author.id }, { it.user.id }) ?: return
-        if (undo(author)) {
-            logAction("undid last send tag.", event)
-            lastTouchedTag.remove(author)
-            doWhen(event, { it.message.messageDelete() }, { reply("Undid last sent tag.", event, ephemeral = true) })
+    override fun CommandEvent.execute(args: List<String>) {
+        if (undo(author.id)) {
+            logAction("undid last send tag.")
+            lastTouchedTag.remove(author.id)
+            doWhen(
+                isMessage = { it.message.messageDelete() },
+                isSlashCommand = { reply("Undid last sent tag.", ephemeral = true) }
+            )
         } else {
             doWhen(
-                event, {
-                    addLastMessage(author, it.message)
+                isMessage = {
+                    addLastMessage(author.id, it.message)
                     it.message.replyWithConsumer("No last tag to undo found!") { consumer ->
-                        addLastMessage(author, consumer.message)
+                        addLastMessage(author.id, consumer.message)
                     }
                     runDelayed(2.seconds) {
-                        undo(author)
+                        undo(author.id)
                     }
-                }, {
-                    sendError("No last tag to undo found!", event)
+                },
+                isSlashCommand = {
+                    sendError("No last tag to undo found!")
                 }
             )
         }

From 57e0bb78cdcb91bbf7c354afc74e7ab2f96abbff Mon Sep 17 00:00:00 2001
From: ILike2WatchMemes <ilike2watchmemes@gmail.com>
Date: Tue, 11 Mar 2025 20:23:25 +0100
Subject: [PATCH 6/9] remove onReady

---
 src/main/kotlin/at/hannibal2/skyhanni/discord/DiscordBot.kt | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/DiscordBot.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/DiscordBot.kt
index d47b57f..cd83434 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/DiscordBot.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/DiscordBot.kt
@@ -84,12 +84,6 @@ private fun startBot(): DiscordBot {
         override fun onCommandAutoCompleteInteraction(event: CommandAutoCompleteInteractionEvent) {
             CommandListener.onAutocomplete(event)
         }
-
-        override fun onReady(event: ReadyEvent) {
-            event.jda.getGuildById(config.allowedServerId)?.let {
-                CommandListener.createCommands(it)
-            }
-        }
     }
     jda.addEventListener(slashCommandListener)
     jda.addEventListener(messageListener)

From b24370521cd569b6985452915d868a719308f055 Mon Sep 17 00:00:00 2001
From: ILike2WatchMemes <ilike2watchmemes@gmail.com>
Date: Tue, 11 Mar 2025 20:36:00 +0100
Subject: [PATCH 7/9] remove wildcard imports

---
 .../at/hannibal2/skyhanni/discord/CommandListener.kt   | 10 ++++++++--
 .../skyhanni/discord/command/ServerCommands.kt         |  4 +++-
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt
index 269f923..9e58896 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt
@@ -3,10 +3,16 @@ package at.hannibal2.skyhanni.discord
 import at.hannibal2.skyhanni.discord.Utils.hasAdminPermissions
 import at.hannibal2.skyhanni.discord.Utils.inBotCommandChannel
 import at.hannibal2.skyhanni.discord.Utils.logAction
-import at.hannibal2.skyhanni.discord.command.*
+import at.hannibal2.skyhanni.discord.command.HelpCommand
+import at.hannibal2.skyhanni.discord.command.BaseCommand
+import at.hannibal2.skyhanni.discord.command.MessageEvent
+import at.hannibal2.skyhanni.discord.command.SlashCommandEvent
+import at.hannibal2.skyhanni.discord.command.ServerCommands
 import at.hannibal2.skyhanni.discord.command.PullRequestCommand.isPullRequest
 import at.hannibal2.skyhanni.discord.command.ServerCommands.isKnownServerUrl
+import at.hannibal2.skyhanni.discord.command.TagCommands
 import at.hannibal2.skyhanni.discord.command.TagCommands.handleTag
+import at.hannibal2.skyhanni.discord.command.TagUndo
 import net.dv8tion.jda.api.entities.Guild
 import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
@@ -117,7 +123,7 @@ object CommandListener {
         with(SlashCommandEvent(this)) {
             if (guild?.id != bot.config.allowedServerId || user.isBot) return
 
-            val command = getCommand(event.fullCommandName) ?: return
+            val command = getCommand(fullCommandName) ?: return
 
             if (!command.userCommand) {
                 if (!hasAdminPermissions()) {
diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/ServerCommands.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/ServerCommands.kt
index 0122a83..df475b0 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/ServerCommands.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/ServerCommands.kt
@@ -1,6 +1,8 @@
 package at.hannibal2.skyhanni.discord.command
 
-import at.hannibal2.skyhanni.discord.*
+import at.hannibal2.skyhanni.discord.BOT
+import at.hannibal2.skyhanni.discord.Option
+import at.hannibal2.skyhanni.discord.Utils
 import at.hannibal2.skyhanni.discord.Utils.logAction
 import at.hannibal2.skyhanni.discord.Utils.sendMessageToBotChannel
 import at.hannibal2.skyhanni.discord.github.GitHubClient

From 86f442e4b4c2066c1e89b0db0873a859186a8823 Mon Sep 17 00:00:00 2001
From: ILike2WatchMemes <ilike2watchmemes@gmail.com>
Date: Wed, 12 Mar 2025 01:18:40 +0100
Subject: [PATCH 8/9] remove long with

---
 .../skyhanni/discord/CommandListener.kt       | 140 +++++++++---------
 .../hannibal2/skyhanni/discord/DiscordBot.kt  |   7 +-
 2 files changed, 70 insertions(+), 77 deletions(-)

diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt
index 9e58896..fd0ce17 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt
@@ -38,11 +38,11 @@ object CommandListener {
         BOT.jda.getGuildById(BOT.config.allowedServerId)?.let { createCommands(it) }
     }
 
-    fun onMessage(bot: DiscordBot, event: MessageReceivedEvent) {
+    fun onMessage(bot: DiscordBot, event: MessageEvent) {
         event.onMessage(bot)
     }
 
-    fun onInteraction(bot: DiscordBot, event: SlashCommandInteractionEvent) {
+    fun onInteraction(bot: DiscordBot, event: SlashCommandEvent) {
         event.onInteraction(bot)
     }
 
@@ -50,100 +50,96 @@ object CommandListener {
         event.onCompletion()
     }
 
-    private fun MessageReceivedEvent.onMessage(bot: DiscordBot) {
-        with(MessageEvent(this)) {
-            val message = message.contentRaw.trim()
-            if (!isFromGuild) {
-                logAction("private dm: '$message'")
-                return
-            }
-            if (guild.id != bot.config.allowedServerId) return
+    private fun MessageEvent.onMessage(bot: DiscordBot) {
+        val message = message.contentRaw.trim()
+        if (!isFromGuild) {
+            logAction("private dm: '$message'")
+            return
+        }
+        if (event.guild.id != bot.config.allowedServerId) return
 
-            if (author.isBot) {
-                if (author.id == BOT_ID) {
-                    BotMessageHandler.handle(event)
-                }
-                return
+        if (author.isBot) {
+            if (author.id == BOT_ID) {
+                BotMessageHandler.handle(event)
             }
+            return
+        }
 
-            if (TagUndo.getAllNames().none { "!$it" == message }) {
-                TagCommands.lastMessages.remove(author.id)
-            }
+        if (TagUndo.getAllNames().none { "!$it" == message }) {
+            TagCommands.lastMessages.remove(author.id)
+        }
 
-            if (isKnownServerUrl(message) || isPullRequest(message) || !isCommand(message)) return
+        if (isKnownServerUrl(message) || isPullRequest(message) || !isCommand(message)) return
 
-            val split = message.substring(1).split(" ")
-            val literal = split.first().lowercase()
-            val args = split.drop(1)
+        val split = message.substring(1).split(" ")
+        val literal = split.first().lowercase()
+        val args = split.drop(1)
 
-            val command = getCommand(literal) ?: run {
-                handleTag()
+        val command = getCommand(literal) ?: run {
+            handleTag()
+            return
+        }
+
+        if (!command.userCommand) {
+            if (!hasAdminPermissions()) {
+                reply("No permissions $PLEADING_FACE")
                 return
             }
 
-            if (!command.userCommand) {
-                if (!hasAdminPermissions()) {
-                    reply("No permissions $PLEADING_FACE")
-                    return
-                }
-
-                if (!inBotCommandChannel()) {
-                    reply("Wrong channel $PLEADING_FACE")
-                    return
-                }
+            if (!inBotCommandChannel()) {
+                reply("Wrong channel $PLEADING_FACE")
+                return
             }
+        }
 
-            // allows to use `!<command> -help` instead of `!help -<command>`
-            if (args.size == 1 && args.first() == "-help") {
+        // allows to use `!<command> -help` instead of `!help -<command>`
+        if (args.size == 1 && args.first() == "-help") {
+            with(HelpCommand) {
+                sendUsageReply(literal)
+            }
+            return
+        }
+        // allows to use `!<command> -help` instead of `!help -<command>`
+        if (args.size == 1) {
+            if (args.first() == "-help") {
                 with(HelpCommand) {
                     sendUsageReply(literal)
                 }
                 return
             }
-            // allows to use `!<command> -help` instead of `!help -<command>`
-            if (args.size == 1) {
-                if (args.first() == "-help") {
-                    with(HelpCommand) {
-                        sendUsageReply(literal)
-                    }
-                    return
-                }
-            }
-            try {
-                with(command) {
-                    execute(args)
-                }
-            } catch (e: Exception) {
-                reply("Error: ${e.message}")
+        }
+        try {
+            with(command) {
+                execute(args)
             }
+        } catch (e: Exception) {
+            reply("Error: ${e.message}")
         }
     }
 
-    private fun SlashCommandInteractionEvent.onInteraction(bot: DiscordBot) {
-        with(SlashCommandEvent(this)) {
-            if (guild?.id != bot.config.allowedServerId || user.isBot) return
+    private fun SlashCommandEvent.onInteraction(bot: DiscordBot) {
+        if (event.guild?.id != bot.config.allowedServerId || author.isBot) return
 
-            val command = getCommand(fullCommandName) ?: return
+        val command = getCommand(event.fullCommandName) ?: return
 
-            if (!command.userCommand) {
-                if (!hasAdminPermissions()) {
-                    reply("No permissions $PLEADING_FACE")
-                    return
-                }
+        if (!command.userCommand) {
+            if (!hasAdminPermissions()) {
+                reply("No permissions $PLEADING_FACE")
+                return
+            }
 
-                if (!inBotCommandChannel()) {
-                    reply("Wrong channel $PLEADING_FACE")
-                    return
-                }
+            if (!inBotCommandChannel()) {
+                reply("Wrong channel $PLEADING_FACE")
+                return
             }
+        }
 
-            try {
-                with(command) {
-                    execute(listOf())
-                }
-            } catch (e: Exception) {
-                reply("Error: ${e.message}")
+        try {
+            with(command) {
+                execute(listOf())
             }
+        } catch (e: Exception) {
+            reply("Error: ${e.message}")
         }
     }
 
@@ -224,10 +220,6 @@ object CommandListener {
     private fun createCommands(guild: Guild) {
         guild.retrieveCommands().queue {
             val commandData = commands.map { value -> convertToData(value) }
-            println(getCommand("server"))
-
-            println(commandsMap)
-            println(commandData)
 
             guild.updateCommands().addCommands(commandData).queue()
         }
diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/DiscordBot.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/DiscordBot.kt
index cd83434..977339f 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/DiscordBot.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/DiscordBot.kt
@@ -1,12 +1,13 @@
 package at.hannibal2.skyhanni.discord
 
 import at.hannibal2.skyhanni.discord.Utils.sendMessageToBotChannel
+import at.hannibal2.skyhanni.discord.command.MessageEvent
+import at.hannibal2.skyhanni.discord.command.SlashCommandEvent
 import net.dv8tion.jda.api.JDA
 import net.dv8tion.jda.api.JDABuilder
 import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
 import net.dv8tion.jda.api.events.message.MessageReceivedEvent
-import net.dv8tion.jda.api.events.session.ReadyEvent
 import net.dv8tion.jda.api.hooks.ListenerAdapter
 import net.dv8tion.jda.api.requests.GatewayIntent
 import org.slf4j.Logger
@@ -73,12 +74,12 @@ private fun startBot(): DiscordBot {
     val bot = DiscordBot(jda, config)
     val messageListener = object : ListenerAdapter() {
         override fun onMessageReceived(event: MessageReceivedEvent) {
-            CommandListener.onMessage(bot, event)
+            CommandListener.onMessage(bot, MessageEvent(event))
         }
     }
     val slashCommandListener = object : ListenerAdapter() {
         override fun onSlashCommandInteraction(event: SlashCommandInteractionEvent) {
-            CommandListener.onInteraction(bot, event)
+            CommandListener.onInteraction(bot, SlashCommandEvent(event))
         }
 
         override fun onCommandAutoCompleteInteraction(event: CommandAutoCompleteInteractionEvent) {

From f4b676d807604abe62bdbcb5874178ffeded931c Mon Sep 17 00:00:00 2001
From: ILike2WatchMemes <ilike2watchmemes@gmail.com>
Date: Thu, 10 Apr 2025 17:13:00 +0200
Subject: [PATCH 9/9] updates

---
 .../skyhanni/discord/CommandListener.kt       |  6 +--
 .../skyhanni/discord/command/CommandEvent.kt  |  8 ++--
 .../skyhanni/discord/command/HelpCommand.kt   | 10 ++---
 .../discord/command/PullRequestCommand.kt     | 44 +++++++++++--------
 .../discord/command/ServerCommands.kt         | 21 +++++----
 .../skyhanni/discord/command/TagCommands.kt   | 21 ++++-----
 6 files changed, 59 insertions(+), 51 deletions(-)

diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt
index d2787b2..d3c2eba 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt
@@ -15,8 +15,6 @@ import at.hannibal2.skyhanni.discord.command.TagCommands.handleTag
 import at.hannibal2.skyhanni.discord.command.TagUndo
 import net.dv8tion.jda.api.entities.Guild
 import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent
-import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
-import net.dv8tion.jda.api.events.message.MessageReceivedEvent
 import net.dv8tion.jda.api.interactions.commands.OptionType
 import net.dv8tion.jda.api.interactions.commands.build.Commands
 import net.dv8tion.jda.api.interactions.commands.build.SlashCommandData
@@ -169,7 +167,7 @@ object CommandListener {
                 if (focusedOption.name != "keyword") return
 
                 replyChoiceStrings(
-                    Database.listKeywords().filter { it.startsWith(focusedOption.value, true) }
+                    Database.listTags().filter { it.keyword.startsWith(focusedOption.value, true) }.map { it.keyword }
                         .take(25)
                 ).queue()
             }
@@ -178,7 +176,7 @@ object CommandListener {
                 if (focusedOption.name != "keyword") return
 
                 replyChoiceStrings(
-                    Database.listKeywords().filter { it.startsWith(focusedOption.value, true) }
+                    Database.listTags().filter { it.keyword.startsWith(focusedOption.value, true) }.map { it.keyword }
                         .take(25)
                 ).queue()
             }
diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/CommandEvent.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/CommandEvent.kt
index cf2503e..427c013 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/CommandEvent.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/CommandEvent.kt
@@ -6,7 +6,7 @@ import net.dv8tion.jda.api.entities.Member
 import net.dv8tion.jda.api.entities.Message
 import net.dv8tion.jda.api.entities.MessageEmbed
 import net.dv8tion.jda.api.entities.User
-import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel
+import net.dv8tion.jda.api.entities.channel.unions.MessageChannelUnion
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
 import net.dv8tion.jda.api.events.message.MessageReceivedEvent
 
@@ -16,7 +16,7 @@ abstract class CommandEvent {
 
     abstract val author: User
 
-    abstract val channel: MessageChannel
+    abstract val channel: MessageChannelUnion
 
     abstract val message: Message?
 
@@ -52,7 +52,7 @@ class MessageEvent(val event: MessageReceivedEvent) : CommandEvent() {
         get() = event.member
     override val author: User
         get() = event.author
-    override val channel: MessageChannel
+    override val channel: MessageChannelUnion
         get() = event.channel
     override val message: Message
         get() = event.message
@@ -81,7 +81,7 @@ class SlashCommandEvent(val event: SlashCommandInteractionEvent) : CommandEvent(
         get() = event.member
     override val author: User
         get() = event.user
-    override val channel: MessageChannel
+    override val channel: MessageChannelUnion
         get() = event.channel
     override val message: Message?
         get() = null
diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/HelpCommand.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/HelpCommand.kt
index 88e7427..bd49fb4 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/HelpCommand.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/HelpCommand.kt
@@ -65,17 +65,17 @@ object HelpCommand : BaseCommand() {
             return
         }
 
-        reply(createHelpEmbed(commandName))
+        reply(command.createHelpEmbed())
     }
 
-    private fun BaseCommand.createHelpEmbed(commandName: String): MessageEmbed {
+    private fun BaseCommand.createHelpEmbed(): MessageEmbed {
         val em = EmbedBuilder()
 
-        em.setTitle("Usage: /$commandName <" + this.options.joinToString("> <") { it.name } + ">")
-        em.setDescription("📋 **${this.description}**")
+        em.setTitle("Usage: /$name " + options.joinToString("> <", prefix = "<", postfix = ">") { it.name })
+        em.setDescription("📋 **${description}**")
         em.setColor(Color.GREEN)
 
-        for (option in this.options) {
+        for (option in options) {
             em.addField(option.name, option.description, true)
             em.addField("Required", if (option.required) "✅" else "❌", true)
             em.addBlankField(true)
diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/PullRequestCommand.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/PullRequestCommand.kt
index 17dbd23..7664e77 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/PullRequestCommand.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/PullRequestCommand.kt
@@ -14,17 +14,13 @@ import at.hannibal2.skyhanni.discord.Utils.format
 import at.hannibal2.skyhanni.discord.Utils.linkTo
 import at.hannibal2.skyhanni.discord.Utils.logAction
 import at.hannibal2.skyhanni.discord.Utils.messageDelete
-import at.hannibal2.skyhanni.discord.Utils.reply
-import at.hannibal2.skyhanni.discord.Utils.replyWithConsumer
 import at.hannibal2.skyhanni.discord.Utils.runDelayed
 import at.hannibal2.skyhanni.discord.Utils.timeExecution
 import at.hannibal2.skyhanni.discord.Utils.uploadFile
-import at.hannibal2.skyhanni.discord.Utils.userError
 import at.hannibal2.skyhanni.discord.github.GitHubClient
 import at.hannibal2.skyhanni.discord.json.discord.Conclusion
 import at.hannibal2.skyhanni.discord.json.discord.PullRequestJson
 import at.hannibal2.skyhanni.discord.json.discord.RunStatus
-import net.dv8tion.jda.api.events.message.MessageReceivedEvent
 import java.awt.Color
 import java.io.File
 import java.time.Instant
@@ -52,21 +48,33 @@ object PullRequestCommand : BaseCommand() {
         Regex("https://github\\.com/[\\w.]+/[\\w.]+/actions/runs/(?<RunId>\\d+)/job/(?<JobId>\\d+)")
     private val pullRequestPattern = "$BASE/pull/(?<pr>\\d+)".toPattern()
 
-    override fun MessageReceivedEvent.execute(args: List<String>) {
-        if (args.size != 1) return wrongUsage("<number>")
-        val first = args.first()
-        val prNumber = first.toLongOrNull() ?: run {
-            userError("Unknown number $PLEADING_FACE ($first})")
-            return
+    override fun CommandEvent.execute(args: List<String>) {
+        if (args.isNotEmpty() && args.size != 1) {
+            return wrongUsage("<number>")
         }
+
+        val prNumber = doWhen(
+            isMessage = {
+                val first = args.first()
+                first.toLongOrNull() ?: run {
+                    userError("Unknown number $PLEADING_FACE ($first})")
+                    null
+                }
+            },
+            isSlashCommand = {
+                it.getOption("number")?.asLong
+            }
+        ) ?: return
+
         if (prNumber < 1) {
             userError("PR number needs to be positive $PLEADING_FACE")
             return
         }
+
         loadPrInfos(prNumber)
     }
 
-    private fun MessageReceivedEvent.loadPrInfos(prNumber: Long) {
+    private fun CommandEvent.loadPrInfos(prNumber: Long) {
         logAction("loads pr infos for #$prNumber")
 
         val prLink = "$BASE/pull/$prNumber"
@@ -242,7 +250,7 @@ object PullRequestCommand : BaseCommand() {
         stringBuilder: StringBuilder,
         suffix: String = ""
     ): StringBuilder {
-        val labelsWithType = labels.intersect(labelTypes[labelType] ?: setOf())
+        val labelsWithType = labels.intersect((labelTypes[labelType] ?: setOf()).toSet())
         if (labelsWithType.isEmpty()) return stringBuilder.append(if (suffix.isNotEmpty()) "> $labelType: $suffix\n" else "")
         return stringBuilder.append("> $labelType: `${labelsWithType.joinToString("` `")}`$suffix\n")
     }
@@ -268,13 +276,13 @@ object PullRequestCommand : BaseCommand() {
     }
 
     @Suppress("unused") // TODO implement once we can upload the file
-    private fun MessageReceivedEvent.pullRequestArtifactCommand(args: List<String>) {
+    private fun CommandEvent.pullRequestArtifactCommand(args: List<String>) {
         if (args.size != 2) {
             reply("Usage: `!prupload <number>`")
             return
         }
         val prNumber = args[1].toLongOrNull() ?: run {
-            reply("unknwon number $PLEADING_FACE (${args[1]})")
+            reply("unknown number $PLEADING_FACE (${args[1]})")
             return
         }
 
@@ -304,7 +312,7 @@ object PullRequestCommand : BaseCommand() {
         val (_, downloadTime) = timeExecution {
             github.downloadArtifact(artifactId, fileRaw)
         }
-        reply("artifact downnloaded in ${downloadTime.format()}")
+        reply("artifact downloaded in ${downloadTime.format()}")
 
         Utils.unzipFile(fileRaw, fileUnzipped)
         fileRaw.delete()
@@ -327,16 +335,16 @@ object PullRequestCommand : BaseCommand() {
         return directory.walkTopDown().firstOrNull { it.isFile && it.name.startsWith("SkyHanni-") }
     }
 
-    fun isPullRequest(event: MessageReceivedEvent, message: String): Boolean {
+    fun MessageEvent.isPullRequest(message: String): Boolean {
         val matcher = pullRequestPattern.matcher(message)
         if (!matcher.matches()) return false
         val pr = matcher.group("pr")?.toLongOrNull() ?: return false
-        event.replyWithConsumer("Next time just type `!pr $pr` $PLEADING_FACE") { consumer ->
+        replyWithConsumer("Next time just type `!pr $pr` $PLEADING_FACE") { consumer ->
             runDelayed(10.seconds) {
                 consumer.message.messageDelete()
             }
         }
-        event.loadPrInfos(pr)
+        loadPrInfos(pr)
         return true
     }
 
diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/ServerCommands.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/ServerCommands.kt
index 1c2da3a..89df135 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/ServerCommands.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/ServerCommands.kt
@@ -5,14 +5,12 @@ import at.hannibal2.skyhanni.discord.Option
 import at.hannibal2.skyhanni.discord.Utils
 import at.hannibal2.skyhanni.discord.Utils.logAction
 import at.hannibal2.skyhanni.discord.Utils.sendMessageToBotChannel
-import at.hannibal2.skyhanni.discord.Utils.userError
 import at.hannibal2.skyhanni.discord.command.ServerCommands.loadServers
 import at.hannibal2.skyhanni.discord.github.GitHubClient
 import com.google.gson.Gson
 import com.google.gson.reflect.TypeToken
-import net.dv8tion.jda.api.interactions.commands.OptionType
 import net.dv8tion.jda.api.entities.Invite
-import net.dv8tion.jda.api.events.message.MessageReceivedEvent
+import net.dv8tion.jda.api.interactions.commands.OptionType
 import java.util.concurrent.CountDownLatch
 import kotlin.time.Duration.Companion.milliseconds
 
@@ -248,7 +246,7 @@ class ServerCommand : BaseCommand() {
 
         val debug = doWhen(
             isMessage = { args.getOrNull(1) == "-d" },
-            isSlashCommand = { it.getOption("debug")?.asBoolean == true }
+            isSlashCommand = { it.getOption("debug")?.asBoolean }
         ) ?: false
 
         val server = ServerCommands.getServer(keyword.lowercase())
@@ -272,14 +270,21 @@ class ServerUpdate : BaseCommand() {
     }
 
     override fun CommandEvent.execute(args: List<String>) {
-        reply("updating server list ...")
+        doWhen(
+            isMessage = { reply("updating server list ...") },
+            isSlashCommand = { it.deferReply(true).queue() }
+        )
+
         loadServers(startup = false) { source, removed ->
             val removedSuffix = if (removed > 0) {
                 " (removed $removed servers)"
             } else ""
-            reply(
-            "Updated server list from $source.$removedSuffix"
-        )
+
+            doWhen(
+                isMessage = { reply("Updated server list from $source.$removedSuffix") },
+                isSlashCommand = { it.hook.sendMessage("Updated server list from $source.$removedSuffix").queue() }
+            )
+
             logAction("updated server list from github")
         }
     }
diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/TagCommands.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/TagCommands.kt
index cccdd4c..209be73 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/TagCommands.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/TagCommands.kt
@@ -6,7 +6,6 @@ import at.hannibal2.skyhanni.discord.Option
 import at.hannibal2.skyhanni.discord.PING_HANNIBAL
 import at.hannibal2.skyhanni.discord.PLEADING_FACE
 import at.hannibal2.skyhanni.discord.Tag
-import at.hannibal2.skyhanni.discord.Utils
 import at.hannibal2.skyhanni.discord.Utils.logAction
 import at.hannibal2.skyhanni.discord.Utils.messageDelete
 import at.hannibal2.skyhanni.discord.Utils.messageDeleteAndThen
@@ -91,7 +90,7 @@ class TagList : BaseCommand() {
     override fun CommandEvent.execute(args: List<String>) {
         val list = Database.listTags()
         if (list.isEmpty()) {
-            reply("No tags set.")
+            reply("No tags set.", ephemeral = true)
             return
         }
 
@@ -111,7 +110,8 @@ class TagEdit : BaseCommand() {
     override val name = "tagedit"
     override val description = "Edits a tag in the database."
     override val options: List<Option> = listOf(
-        Option("keyword", "The tag you want to edit.", autoComplete = true), Option("response", "Response you want the tag to have.")
+        Option("keyword", "The tag you want to edit.", autoComplete = true),
+        Option("response", "Response you want the tag to have.")
     )
     override val aliases = listOf("tagchange")
 
@@ -191,19 +191,16 @@ class TagAdd : BaseCommand() {
             it.getOption("keyword")?.asString
         }) ?: return
 
-        if (CommandListener.existsCommand(keyword)) {
-            reply(
-                "Can not create tag `!$keyword`. There is already a command with that name",
-            )
-            return
-        }
+        if (CommandListener.existsCommand(keyword))
+            return userError("Can not create tag `!$keyword`. There is already a command with that name")
+        if (Database.containsKeyword(keyword))
+            return userError("Keyword already exists. Use `!tagedit` instead.")
+
         val response = doWhen(
             isMessage = { args.drop(1).joinToString(" ") },
             isSlashCommand = { it.getOption("response")?.asString }
         ) ?: return
-        if (Database.containsKeyword(keyword)) {
-            return userError("Keyword already exists. Use `!tagedit` instead.")
-        }
+
         if (Database.addTag(keyword, response)) {
             doWhen(isMessage = { it.message.messageDelete() }, isSlashCommand = {})