Other slash commands working

rocketbot/bot.py

 	"""
 	def __init__(self, command_prefix, **kwargs):
 		super().__init__(command_prefix, **kwargs)
+		self.__commands_set_up = False
 
 	async def on_command_error(self, context: commands.Context, exception: BaseException) -> None:
 		bot_log(None, None, f'Command error')
 			traceback.format_exc())
 
 	async def on_ready(self):
+		if not self.__commands_set_up:
+			await self.__set_up_commands()
+		bot_log(None, None, 'Bot done initializing')
+		print('----------------------------------------------------------')
+
+	async def __set_up_commands(self):
+		if self.__commands_set_up:
+			return
+		self.__commands_set_up = True
 		for cog in self.cogs.values():
 			if isinstance(cog, BaseCog):
 				bcog: BaseCog = cog

rocketbot/cogs/autokickcog.py

 	STATE_KEY_RECENT_KICKS = "AutoKickCog.recent_joins"
 
 	def __init__(self, bot):
-		super().__init__(bot, 'autokick')
+		super().__init__(
+			bot,
+			config_prefix='autokick',
+			name='auto-kick',
+			short_description='Automatically kicks all new users as soon as they join.',
+		)
 		self.add_setting(AutoKickCog.SETTING_ENABLED)
 		self.add_setting(AutoKickCog.SETTING_BAN_COUNT)
 		self.add_setting(AutoKickCog.SETTING_OFFLINE_ONLY)
 		timer: Loop = self.status_check_timer
 		timer.start()
 
-	@commands.group(
-		brief='Automatically kicks all new users as soon as they join',
-	)
-	@commands.has_permissions(ban_members=True)
-	@commands.guild_only()
-	async def autokick(self, context: commands.Context):
-		"""Auto-kick"""
-		if context.invoked_subcommand is None:
-			await context.send_help()
-
 	@commands.Cog.listener()
 	async def on_member_join(self, member: Member) -> None:
 		"""Event handler"""

rocketbot/cogs/basecog.py

 from datetime import datetime, timedelta, timezone
 from typing import Optional, ForwardRef
 
-from discord import Guild, Member, Message, RawReactionActionEvent, TextChannel
+import discord
+from discord import Guild, Interaction, Member, Message, RawReactionActionEvent, TextChannel
 from discord.abc import GuildChannel
-from discord.ext import commands
+from discord.app_commands import AppCommandError
+from discord.app_commands.errors import CommandInvokeError
+from discord.ext.commands import Cog
 
 from config import CONFIG
 from rocketbot.botmessage import BotMessage, BotMessageReaction
 from rocketbot.cogsetting import CogSetting
 from rocketbot.collections import AgeBoundDict
 from rocketbot.storage import Storage
-from rocketbot.utils import bot_log
+from rocketbot.utils import bot_log, dump_stacktrace
 
 Rocketbot = ForwardRef('rocketbot.bot.Rocketbot')
 
 		self.member = member
 		self.last_warned = warn_time
 
-class BaseCog(commands.Cog):
+class BaseCog(Cog):
 	STATE_KEY_RECENT_WARNINGS = "BaseCog.recent_warnings"
 
 	"""
 	Superclass for all Rocketbot cogs. Provides lots of conveniences for
 	common tasks.
 	"""
-	def __init__(self, bot: Rocketbot, config_prefix: Optional[str]):
+	def __init__(
+			self,
+			bot: Rocketbot,
+			config_prefix: Optional[str],
+			name: str,
+			short_description: str,
+			long_description: Optional[str] = None,
+	):
 		"""
 		Parameters
 		----------
 		self.are_settings_setup: bool = False
 		self.settings: list[CogSetting] = []
 		self.config_prefix: Optional[str] = config_prefix
+		self.name: str = name
+		self.short_description: str = short_description
+		self.long_description: str = long_description
+
+	async def cog_app_command_error(self, interaction: Interaction, error: AppCommandError) -> None:
+		if isinstance(error, CommandInvokeError):
+			error = error.original
+		dump_stacktrace(error)
+		message = f"\nException: {error.__class__.__name__}, "\
+				  f"Command: {interaction.command.qualified_name if interaction.command else None}, "\
+				  f"User: {interaction.user}, "\
+				  f"Time: {discord.utils.format_dt(interaction.created_at, style='F')}"
+		try:
+			await interaction.response.send_message(f"An error occurred: {message}", ephemeral=True)
+		except discord.InteractionResponded:
+			await interaction.followup.send(f"An error occurred: {message}", ephemeral=True)
 
 	# Config
 
 		await message.update()
 		return message.is_sent()
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_raw_reaction_add(self, payload: RawReactionActionEvent):
 		"""Event handler"""
 		# Avoid any unnecessary requests. Gets called for every reaction

rocketbot/cogs/configcog.py

 """
 Cog handling general configuration for a guild.
 """
-from discord import Guild, TextChannel
-from discord.ext import commands
+from typing import Union, Optional
+
+from discord import Guild, Permissions, TextChannel, Interaction, Role, User
+from discord.app_commands import Group
 from discord.ext.commands import Bot
 
 from config import CONFIG
 	"""
 
 	def __init__(self, bot: Bot) -> None:
-		super().__init__(bot, 'config')
+		super().__init__(
+			bot,
+			config_prefix='config',
+			name='configuration',
+			short_description='Manages general bot configuration.',
+		)
 
-	@commands.group(
-		brief='Manages general bot configuration'
+	config = Group(
+		name='config',
+		description='Manages general bot configuration',
+		guild_only=True,
+		default_permissions=Permissions(Permissions.manage_messages.flag)
 	)
-	@commands.has_permissions(ban_members=True)
-	@commands.guild_only()
-	async def config(self, context: commands.Context):
-		"""General guild configuration command group"""
-		if context.invoked_subcommand is None:
-			await context.send_help()
 
 	@config.command(
-		brief='Sets the mod warning channel',
-		description='Run this command in the channel where bot messages ' +
-			'intended for server moderators should be sent. Other bot ' +
-			'messages may still be posted in the channel a command was ' +
-			'invoked in. If no output channel is set, mod-related messages ' +
-			'will not be posted!',
+		description='Sets the mod warning channel',
+		extras={
+			'long_description': 'Run this command in the channel where bot messages ' +
+				'intended for server moderators should be sent. Other bot ' +
+				'messages may still be posted in the channel a command was ' +
+				'invoked in. If no output channel is set, mod-related messages ' +
+				'will not be posted!',
+		}
 	)
-	async def setwarningchannel(self, context: commands.Context) -> None:
+	async def setwarningchannel(self, interaction: Interaction) -> None:
 		"""Command handler"""
-		guild: Guild = context.guild
-		channel: TextChannel = context.channel
+		guild: Guild = interaction.guild
+		channel: TextChannel = interaction.channel
 		Storage.set_config_value(guild, ConfigKey.WARNING_CHANNEL_ID,
-			context.channel.id)
-		await context.message.reply(
+			interaction.channel.id)
+		await interaction.response.send_message(
 			f'{CONFIG["success_emoji"]} Warning channel updated to {channel.mention}.',
-			mention_author=False)
+			ephemeral=True,
+		)
 
 	@config.command(
-		brief='Shows the mod warning channel',
-		description='Shows the configured channel (if any) where mod ' + \
-			'warnings will be posted.',
+		description='Shows the mod warning channel',
+		extras={
+			'long_description': 'Shows the configured channel (if any) where mod ' + \
+				'warnings will be posted.',
+		},
 	)
-	async def getwarningchannel(self, context: commands.Context) -> None:
+	async def getwarningchannel(self, interaction: Interaction) -> None:
 		"""Command handler"""
-		guild: Guild = context.guild
+		guild: Guild = interaction.guild
 		channel_id = Storage.get_config_value(guild, ConfigKey.WARNING_CHANNEL_ID)
 		if channel_id is None:
-			await context.message.reply(
+			await interaction.response.send_message(
 				f'{CONFIG["info_emoji"]} No warning channel is configured.',
-				mention_author=False)
+				ephemeral=True,
+			)
 		else:
 			channel = guild.get_channel(channel_id)
-			await context.message.reply(
+			await interaction.response.send_message(
 				f'{CONFIG["info_emoji"]} Warning channel is configured as {channel.mention}.',
-				mention_author=False)
+				ephemeral=True,
+			)
 
 	@config.command(
-		brief='Sets a user/role to mention in warning messages',
-		usage='<@user|@role>',
-		description='Configures an role or other prefix to include at the ' +
-			'beginning of warning messages. If the intent is to get the ' +
-			'attention of certain users, be sure to specify a properly ' +
-			'formed @ tag, not just the name of the user/role.'
+		description='Sets a user/role to mention in warning messages',
+		extras={
+			'usage': '<@user|@role>',
+			'long_description': 'Configures an role or other prefix to include at the ' +
+				'beginning of warning messages. If the intent is to get the ' +
+				'attention of certain users, be sure to specify a properly ' +
+				'formed @ tag, not just the name of the user/role.',
+		},
 	)
 	async def setwarningmention(self,
-			context: commands.Context,
-			mention: str = None) -> None:
+			interaction: Interaction,
+			mention: Optional[Union[User, Role]] = None) -> None:
 		"""Command handler"""
-		guild: Guild = context.guild
-		Storage.set_config_value(guild, ConfigKey.WARNING_MENTION, mention)
+		guild: Guild = interaction.guild
+		Storage.set_config_value(guild, ConfigKey.WARNING_MENTION, mention.mention if mention else None)
 		if mention is None:
-			await context.message.reply(
+			await interaction.response.send_message(
 				f'{CONFIG["success_emoji"]} Warning messages will not tag anyone.',
-				mention_author=False)
+				ephemeral=True,
+			)
 		else:
-			await context.message.reply(
+			await interaction.response.send_message(
 				f'{CONFIG["success_emoji"]} Warning messages will now tag {mention}.',
-				mention_author=False)
+				ephemeral=True,
+			)
 
 	@config.command(
-		brief='Shows the user/role to mention in warning messages',
-		description='Shows the text, if any, that will be prefixed on any ' +
-			'warning messages.'
+		description='Shows the user/role to mention in warning messages',
+		extras={
+			'long_description': 'Shows the text, if any, that will be prefixed on any ' +
+				'warning messages.',
+		},
 	)
-	async def getwarningmention(self, context: commands.Context) -> None:
+	async def getwarningmention(self, interaction: Interaction) -> None:
 		"""Command handler"""
-		guild: Guild = context.guild
+		guild: Guild = interaction.guild
 		mention: str = Storage.get_config_value(guild, ConfigKey.WARNING_MENTION)
 		if mention is None:
-			await context.message.reply(
+			await interaction.response.send_message(
 				f'{CONFIG["info_emoji"]} No warning mention configured.',
-				mention_author=False)
+				ephemeral=True,
+			)
 		else:
-			await context.message.reply(
+			await interaction.response.send_message(
 				f'{CONFIG["info_emoji"]} Warning messages will tag {mention}',
-				mention_author=False)
+				ephemeral=True,
+			)

rocketbot/cogs/crosspostcog.py

 from typing import Optional
 
 from discord import Member, Message, utils as discordutils, TextChannel
-from discord.ext import commands
+from discord.ext.commands import Cog
 
 from config import CONFIG
 from rocketbot.cogs.basecog import BaseCog, BotMessage, BotMessageReaction, CogSetting
 			'messages like "lol" or a single emoji.',
 		usage='<character_count:int>',
 		min_value=1)
-	SETTING_TIMESPAN = CogSetting('timespan', float,
+	SETTING_TIMESPAN = CogSetting('timespan', timedelta,
 		brief='time window to look for dupe messages',
 		description='The number of seconds of message history to look at ' + \
 			'when looking for duplicates. Shorter values are preferred, ' + \
 	STATE_KEY_SPAM_CONTEXT = "CrossPostCog.spam_context"
 
 	def __init__(self, bot):
-		super().__init__(bot, 'crosspost')
+		super().__init__(
+			bot,
+			config_prefix='crosspost',
+			name='crosspost detection',
+			short_description='Manages crosspost detection and handling.',
+		)
 		self.add_setting(CrossPostCog.SETTING_ENABLED)
 		self.add_setting(CrossPostCog.SETTING_WARN_COUNT)
 		self.add_setting(CrossPostCog.SETTING_DUPE_WARN_COUNT)
 		# print(message)
 		pass
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_message(self, message: Message):
 		"""Event handler"""
 		if message.author is None or \
 			return
 		self.__trace("--ON MESSAGE--")
 		await self.__record_message(message)
-
-	@commands.group(
-		brief='Manages crosspost detection and handling',
-	)
-	@commands.has_permissions(ban_members=True)
-	@commands.guild_only()
-	async def crosspost(self, context: commands.Context):
-		"""Detects members posting messages in multiple channels in a short period of time."""
-		if context.invoked_subcommand is None:
-			await context.send_help()

rocketbot/cogs/generalcog.py

 """
 Cog for handling most ungrouped commands and basic behaviors.
 """
-import re
 from datetime import datetime, timedelta, timezone
 from typing import Optional
 
-from discord import Message
+from discord import Interaction, Message, User
+from discord.app_commands import command, default_permissions, guild_only, Transform
 from discord.errors import DiscordException
-from discord.ext import commands
+from discord.ext.commands import Cog
 
 from config import CONFIG
 from rocketbot.bot import Rocketbot
 from rocketbot.cogs.basecog import BaseCog, BotMessage
-from rocketbot.utils import timedelta_from_str, describe_timedelta, dump_stacktrace
+from rocketbot.utils import describe_timedelta, TimeDeltaTransformer
 from rocketbot.storage import ConfigKey, Storage
 
 class GeneralCog(BaseCog, name='General'):
 	first cog added to the bot.
 	"""
 	def __init__(self, bot: Rocketbot):
-		super().__init__(bot, None)
+		super().__init__(
+			bot,
+			config_prefix=None,
+			name='',
+			short_description='',
+		)
 		self.is_connected = False
-		self.is_ready = False
-		self.is_first_ready = True
 		self.is_first_connect = True
 		self.last_disconnect_time: Optional[datetime] = None
 		self.noteworthy_disconnect_duration = timedelta(seconds=5)
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_connect(self):
 		"""Event handler"""
 		if self.is_first_connect:
 				self.log(None, f'Reconnected after {disconnect_duration.total_seconds()} seconds')
 		self.is_connected = True
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_disconnect(self):
 		"""Event handler"""
 		self.last_disconnect_time = datetime.now(timezone.utc)
 		# self.log(None, 'Disconnected')
 
-	@commands.Cog.listener()
-	async def on_ready(self):
-		"""Event handler"""
-		self.log(None, 'Bot done initializing')
-		self.is_ready = True
-		if self.is_first_ready:
-			print('----------------------------------------------------------')
-			self.is_first_ready = False
-
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_resumed(self):
 		"""Event handler"""
 		disconnect_duration = datetime.now(timezone.utc) - self.last_disconnect_time if self.last_disconnect_time else None
 		if disconnect_duration is not None and disconnect_duration > self.noteworthy_disconnect_duration:
 			self.log(None, f'Session resumed after {disconnect_duration.total_seconds()} seconds')
 
-	@commands.command(
-		brief='Posts a test warning',
-		description='Tests whether a warning channel is configured for this ' + \
-			'guild by posting a test warning. If a mod mention is ' + \
-			'configured, that user/role will be tagged in the test warning.',
+	@command(
+		description='Posts a test warning',
+		extras={
+			'long_description': 'Tests whether a warning channel is configured for this ' + \
+				'guild by posting a test warning. If a mod mention is ' + \
+				'configured, that user/role will be tagged in the test warning.',
+		},
 	)
-	@commands.has_permissions(ban_members=True)
-	@commands.guild_only()
-	async def testwarn(self, context):
+	@guild_only()
+	@default_permissions(manage_messages=True)
+	async def testwarn(self, interaction: Interaction):
 		"""Command handler"""
-		if Storage.get_config_value(context.guild, ConfigKey.WARNING_CHANNEL_ID) is None:
-			await context.message.reply(
+		if Storage.get_config_value(interaction.guild, ConfigKey.WARNING_CHANNEL_ID) is None:
+			await interaction.response.send_message(
 				f'{CONFIG["warning_emoji"]} No warning channel set!',
-				mention_author=False)
+				ephemeral=True,
+			)
 		else:
 			bm = BotMessage(
-				context.guild,
-				f'Test warning message (requested by {context.author.name})',
+				interaction.guild,
+				f'Test warning message (requested by {interaction.user.name})',
 				type=BotMessage.TYPE_MOD_WARNING)
 			await self.post_message(bm)
+			await interaction.response.send_message(
+				'Warning issued',
+				ephemeral=True,
+			)
 
-	@commands.command(
-		brief='Simple test reply',
-		description='Replies to the command message. Useful to ensure the ' + \
-			'bot is working properly.',
+	@command(
+		description='Simple test reply',
+		extras={
+			'long_description': 'Replies to the command message. Useful to ensure the ' + \
+				'bot is working properly.',
+		},
 	)
-	async def hello(self, context):
+	async def hello(self, interaction: Interaction):
 		"""Command handler"""
-		await context.message.reply(
-			f'Hey, {context.author.name}!',
-		 	mention_author=False)
+		await interaction.response.send_message(
+			f'Hey, {interaction.user.name}!',
+		 	ephemeral=True,
+		)
 
-	@commands.command(
-		brief='Shuts down the bot',
-		description='Causes the bot script to terminate. Only usable by a ' + \
-			'user with server admin permissions.',
+	@command(
+		description='Shuts down the bot',
+		extras={
+			'long_description': 'Causes the bot script to terminate. Only usable by a ' + \
+				'user with server admin permissions.',
+		},
 	)
-	@commands.has_permissions(administrator=True)
-	@commands.guild_only()
-	async def shutdown(self, context: commands.Context):
+	@guild_only()
+	@default_permissions(manage_messages=True)
+	async def shutdown(self, interaction: Interaction):
 		"""Command handler"""
-		await context.message.add_reaction('👋')
+		await interaction.response.send_message('👋', ephemeral=True)
 		await self.bot.close()
 
-	@commands.command(
-		brief='Mass deletes messages',
-		description='Deletes recent messages by the given user. The user ' +
-			'can be either an @ mention or a numeric user ID. The age is ' +
-			'a duration, such as "30s", "5m", "1h30m". Only the most ' +
-			'recent 100 messages in each channel are searched.',
-		usage='<user:id|mention> <age:timespan>'
+	@command(
+		description='Mass deletes messages',
+		extras={
+			'long_description': 'Deletes recent messages by the given user. The user ' +
+				'can be either an @ mention or a numeric user ID. The age is ' +
+				'a duration, such as "30s", "5m", "1h30m". Only the most ' +
+				'recent 100 messages in each channel are searched.',
+			'usage': '<user:id|mention> <age:timespan>',
+		},
 	)
-	@commands.has_permissions(manage_messages=True)
-	@commands.guild_only()
-	async def deletemessages(self, context, user: str, age: str) -> None:
+	@guild_only()
+	@default_permissions(manage_messages=True)
+	async def deletemessages(self, interaction: Interaction, user: User, age: Transform[timedelta, TimeDeltaTransformer]) -> None:
 		"""Command handler"""
-		member_id = self.__parse_member_id(user)
-		if member_id is None:
-			await context.message.reply(
-				f'{CONFIG["failure_emoji"]} user must be a mention or numeric user id',
-				mention_author=False)
-			return
-		try:
-			age_delta: timedelta = timedelta_from_str(age)
-		except ValueError:
-			await context.message.reply(
-				f'{CONFIG["failure_emoji"]} age must be a timespan, like "30s", "10m", "1h30m"',
-				mention_author=False)
-			return
-		cutoff: datetime = datetime.now(timezone.utc) - age_delta
+		member_id = user.id
+		cutoff: datetime = datetime.now(timezone.utc) - age
 		def predicate(message: Message) -> bool:
 			return str(message.author.id) == member_id and message.created_at >= cutoff
 		deleted_messages = []
-		for channel in context.guild.text_channels:
+		for channel in interaction.guild.text_channels:
 			try:
 				deleted_messages += await channel.purge(limit=100, check=predicate)
 			except DiscordException:
 				# XXX: Sloppily glossing over access errors instead of checking access
 				pass
-		await context.message.reply(
+		await interaction.response.send_message(
 			f'{CONFIG["success_emoji"]} Deleted {len(deleted_messages)} ' + \
-			f'messages by <@!{member_id}> from the past {describe_timedelta(age_delta)}.',
-			mention_author=False)
-
-	def __parse_member_id(self, arg: str) -> Optional[str]:
-		p = re.compile('^<@!?([0-9]+)>$')
-		m = p.match(arg)
-		if m:
-			return m.group(1)
-		p = re.compile('^([0-9]+)$')
-		m = p.match(arg)
-		if m:
-			return m.group(1)
-		return None
+			f'messages by {user.mention}> from the past {describe_timedelta(age)}.',
+			ephemeral=True,
+		)

rocketbot/cogs/joinagecog.py

 import weakref
 
 from datetime import datetime, timedelta, timezone
-from discord import Guild, Member
-from discord.ext import commands
+from typing import Optional
+
+from discord import Guild, Member, Interaction
+from discord.app_commands import Group, guild_only, default_permissions, Transform
+from discord.ext.commands import Cog
 
 from config import CONFIG
 from rocketbot.bot import Rocketbot
 from rocketbot.cogs.basecog import BaseCog, BotMessage, BotMessageReaction, CogSetting
 from rocketbot.collections import AgeBoundList
 from rocketbot.storage import Storage
-from rocketbot.utils import timedelta_from_str
+from rocketbot.utils import TimeDeltaTransformer
+
 
 class JoinAgeQueryContext:
 	"""
 	Data about a join age query
 	"""
-	def __init__(self, join_members: list, timespan: str):
+	def __init__(self, join_members: list[Member], timespan: timedelta):
 		self.join_members = list(join_members)
-		self.timespan = timespan
-		self.kicked_members = set()
-		self.banned_members = set()
-		self.results_message_ref = None
+		self.timespan: timedelta = timespan
+		self.kicked_members: set[Member] = set()
+		self.banned_members: set[Member] = set()
+		self.results_message_ref: Optional[weakref.ReferenceType[BotMessage]] = None
 
 class JoinAgeCog(BaseCog, name='Join Age'):
 	"""
 	SETTING_ENABLED = CogSetting('enabled', bool,
 		brief='join age',
 		description='Whether this cog is enabled for a guild.')
-	SETTING_JOIN_TIME = CogSetting('jointime', float,
+	SETTING_JOIN_TIME = CogSetting('jointime', timedelta,
 		brief='maximum length of time to track new joins',
 		description='The number of seconds of join history to maintain.',
 		usage='<seconds:float>',
 	STATE_KEY_RECENT_JOINS = "JoinAgeCog.recent_joins"
 
 	def __init__(self, bot: Rocketbot):
-		super().__init__(bot, 'joinage')
+		super().__init__(
+			bot,
+			config_prefix='joinage',
+			name='join age',
+			short_description='Tracks recently joined users with options to mass kick or ban.',
+		)
 		self.add_setting(JoinAgeCog.SETTING_ENABLED)
 		self.add_setting(JoinAgeCog.SETTING_JOIN_TIME)
 
-	@commands.group(
-		brief='Tracks recently joined users with options to mass kick or ban',
+	joinage = Group(
+		name='joinage',
+		description='Queries for users who joined in the past span of time',
+		extras={
+			'long_description': 'Searches for users who joined the server recently. ' + \
+				'Can use time spans like 30s, 5m, 1h, 7d, etc.',
+			'usage': '<time_period>',
+		}
 	)
-	@commands.has_permissions(ban_members=True)
-	@commands.guild_only()
-	async def joinage(self, context: commands.Context):
-		"""Join age tracking"""
-		if context.invoked_subcommand is None:
-			await context.send_help()
 
 	@joinage.command(
-		brief='Queries for users who joined in the past span of time',
-		description='Searches for users who joined the server recently. ' + \
-			'Can use time spans like 30s, 5m, 1h, 7d, etc.',
-		usage='<time_period>'
+		name='search',
+		description='Searches for users who joined recently',
 	)
-	async def search(self, context: commands.Context, timespan: str):
+	@guild_only()
+	@default_permissions(ban_members=True)
+	async def search(self, interaction: Interaction, timespan: Transform[timedelta, TimeDeltaTransformer]) -> None:
 		"""Command handler"""
-		guild: Guild = context.guild
+		guild: Guild = interaction.guild
 		recent_joins: AgeBoundList[Member, datetime, timedelta] = Storage.get_state_value(guild, self.STATE_KEY_RECENT_JOINS)
 		if recent_joins is None:
 			max_age: timedelta = timedelta(seconds=self.get_guild_setting(guild, self.SETTING_JOIN_TIME))
 			recent_joins = AgeBoundList(max_age, lambda i, member0 : member0.joined_at)
 			Storage.set_state_value(guild, self.STATE_KEY_RECENT_JOINS, recent_joins)
 		results: list = []
-		ts: timedelta = timedelta_from_str(timespan)
-		cutoff: datetime = datetime.now(timezone.utc) - ts
+		cutoff: datetime = datetime.now(timezone.utc) - timespan
 		for member in recent_joins:
 			if member.joined_at > cutoff:
 				results.append(member)
 		ctx.results_message_ref = weakref.ref(msg)
 		await self.__update_results_message(ctx)
 		await self.post_message(msg)
+		await interaction.response.send_message(
+			"Search started",
+			ephemeral=True,
+		)
 
 	async def on_mod_react(self,
 			bot_message: BotMessage,
 			await self.__update_results_message(ctx)
 			self.log(guild, f'Users banned by {reacted_by.name}')
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_member_join(self, member: Member) -> None:
 		"""Event handler"""
 		guild: Guild = member.guild

rocketbot/cogs/joinraidcog.py

 import weakref
 from datetime import datetime, timedelta
 from discord import Guild, Member
-from discord.ext import commands
+from discord.ext.commands import Cog
 
 from config import CONFIG
 from rocketbot.cogs.basecog import BaseCog, BotMessage, BotMessageReaction, CogSetting
 				'window to trigger a mod warning.',
 			usage='<count:int>',
 			min_value=2)
-	SETTING_JOIN_TIME = CogSetting('jointime', float,
+	SETTING_JOIN_TIME = CogSetting('jointime', timedelta,
 			brief='time window length to look for joins',
 			description='The number of seconds of join history to look ' + \
 				'at when counting recent joins. If joincount or more ' + \
 	STATE_KEY_LAST_RAID = "JoinRaidCog.last_raid"
 
 	def __init__(self, bot):
-		super().__init__(bot, 'joinraid')
+		super().__init__(
+			bot,
+			config_prefix='joinraid',
+			name='join raid',
+			short_description='Manages join raid detection and handling.',
+		)
 		self.add_setting(JoinRaidCog.SETTING_ENABLED)
 		self.add_setting(JoinRaidCog.SETTING_JOIN_COUNT)
 		self.add_setting(JoinRaidCog.SETTING_JOIN_TIME)
 
-	@commands.group(
-		brief='Manages join raid detection and handling',
-	)
-	@commands.has_permissions(ban_members=True)
-	@commands.guild_only()
-	async def joinraid(self, context: commands.Context):
-		"""Join raid detection command group"""
-		if context.invoked_subcommand is None:
-			await context.send_help()
-
 	async def on_mod_react(self,
 			bot_message: BotMessage,
 			reaction: BotMessageReaction,
 			await self.__update_warning_message(raid)
 			self.log(guild, f'Join raid users banned by {reacted_by.name}')
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_member_join(self, member: Member) -> None:
 		"""Event handler"""
 		guild: Guild = member.guild

rocketbot/cogs/logcog.py

 Cog for detecting large numbers of guild joins in a short period of time.
 """
 from collections.abc import Sequence
-from datetime import datetime, timezone, timedelta
+from datetime import datetime, timedelta, timezone
 
 from discord import AuditLogAction, AuditLogEntry, Emoji, Guild, GuildSticker, Invite, Member, Message, RawBulkMessageDeleteEvent, RawMessageDeleteEvent, RawMessageUpdateEvent, Role, Thread, User
 from discord.abc import GuildChannel
-from discord.ext import commands, tasks
+from discord.ext import tasks
+from discord.ext.commands import Cog
 from discord.utils import escape_markdown
 from typing import Optional, Tuple, Union, Callable
 import difflib
 	STATE_EVENT_BUFFER = 'LoggingCog.eventBuffer'
 
 	def __init__(self, bot):
-		super().__init__(bot, 'logging')
+		super().__init__(
+			bot,
+			config_prefix='logging',
+			name='logging',
+			short_description='Manages event logging',
+		)
 		self.add_setting(LoggingCog.SETTING_ENABLED)
 		self.flush_buffers.start()
 		self.buffered_guilds: set[Guild] = set()
 	def cog_unload(self) -> None:
 		self.flush_buffers.cancel()
 
-	@commands.group(
-		brief='Manages event logging',
-	)
-	@commands.has_permissions(ban_members=True)
-	@commands.guild_only()
-	async def logging(self, context: commands.Context):
-		"""Logging command group"""
-		if context.invoked_subcommand is None:
-			await context.send_help()
-
 	# Events - Channels
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_guild_channel_delete(self, channel: GuildChannel) -> None:
 		"""
 		Called whenever a guild channel is deleted or created.
 		bot_message = BotMessage(guild, text, BotMessage.TYPE_LOG)
 		await bot_message.update()
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_guild_channel_create(self, channel: GuildChannel) -> None:
 		"""
 		Called whenever a guild channel is deleted or created.
 		bot_message = BotMessage(guild, text, BotMessage.TYPE_LOG)
 		await bot_message.update()
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_guild_channel_update(self, before: GuildChannel, after: GuildChannel) -> None:
 		"""
 		Called whenever a guild channel is updated. e.g. changed name, topic,
 
 	# Events - Guilds
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_guild_available(self, guild: Guild) -> None:
 		pass
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_guild_unavailable(self, guild: Guild) -> None:
 		pass
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_guild_update(self, before: Guild, after: Guild) -> None:
 		pass
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_guild_emojis_update(self, guild: Guild, before: Sequence[Emoji], after: Sequence[Emoji]) -> None:
 		pass
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_guild_stickers_update(self, guild: Guild, before: Sequence[GuildSticker], after: Sequence[GuildSticker]) -> None:
 		pass
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_invite_create(self, invite: Invite) -> None:
 		"""
 		Called when an `Invite` is created. You must have manage_channels to receive this.
 		bot_message = BotMessage(guild, text, BotMessage.TYPE_LOG)
 		await bot_message.update()
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_invite_delete(self, invite: Invite) -> None:
 		"""
 		Called when an `Invite` is deleted. You must have manage_channels to receive this.
 
 	# Events - Members
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_member_join(self, member: Member) -> None:
 		"""
 		Called when a Member joins a Guild.
 			bot_message = BotMessage(guild, text, BotMessage.TYPE_LOG)
 		await bot_message.update()
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_member_remove(self, member: Member) -> None:
 		"""
 		Called when a Member leaves a Guild.
 		bot_message = BotMessage(guild, text, BotMessage.TYPE_LOG)
 		await bot_message.update()
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_member_update(self, before: Member, after: Member) -> None:
 		"""
 		Called when a Member updates their profile.
 		bot_message = BotMessage(guild, text, BotMessage.TYPE_LOG)
 		await bot_message.update()
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_user_update(self, before: User, after: User) -> None:
 		"""
 		Called when a User updates their profile.
 		bot_message = BotMessage(guild, text, BotMessage.TYPE_LOG)
 		await bot_message.update()
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_member_ban(self, guild: Guild, user: Union[User, Member]) -> None:
 		"""
 		Called when user gets banned from a Guild.
 				return entry
 		return None
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_member_unban(self, guild: Guild, user: Union[User, Member]) -> None:
 		"""
 		Called when a User gets unbanned from a Guild.
 	async def before_flush_buffers_start(self) -> None:
 		await self.bot.wait_until_ready()
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_message(self, message: Message) -> None:
 		"""
 		Called when a Message is created and sent.
 		"""
 		# print(f"Saw message {message.id} \"{message.content}\"")
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_message_edit(self, before: Message, after: Message) -> None:
 		"""
 		Called when a Message receives an update event. If the message is not
 
 		self.__buffer_event(guild, 'edit', BufferedMessageEditEvent(guild, channel, before, after))
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_raw_message_edit(self, payload: RawMessageUpdateEvent) -> None:
 		"""
 		Called when a message is edited. Unlike on_message_edit(), this is called
 		bot_message = BotMessage(guild, text, BotMessage.TYPE_LOG, suppress_embeds=True)
 		await bot_message.update()
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_raw_message_delete(self, payload: RawMessageDeleteEvent) -> None:
 		"""
 		Called when a message is deleted. Unlike on_message_delete(), this is
 			return
 		self.__buffer_event(guild, 'delete', BufferedMessageDeleteEvent(guild, channel, payload.message_id, message))
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_raw_bulk_message_delete(self, payload: RawBulkMessageDeleteEvent) -> None:
 		"""
 		Called when a bulk delete is triggered. Unlike on_bulk_message_delete(),
 
 	# Events - Roles
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_guild_role_create(self, role: Role) -> None:
 		"""
 		Called when a Guild creates or deletes a new Role.
 		bot_message = BotMessage(guild, text, BotMessage.TYPE_LOG)
 		await bot_message.update()
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_guild_role_delete(self, role: Role) -> None:
 		"""
 		Called when a Guild creates or deletes a new Role.
 		bot_message = BotMessage(guild, text, BotMessage.TYPE_LOG)
 		await bot_message.update()
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_guild_role_update(self, before: Role, after: Role) -> None:
 		"""
 		Called when a Role is changed guild-wide.
 
 	# Events - Threads
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_thread_create(self, thread: Thread) -> None:
 		pass
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_thread_update(self, before: Thread, after: Thread) -> None:
 		pass
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_thread_delete(self, thread: Thread) -> None:
 		pass
 

rocketbot/cogs/patterncog.py

 	SETTING_PATTERNS = CogSetting('patterns', None)
 
 	def __init__(self, bot: Rocketbot):
-		super().__init__(bot, 'patterns')
+		super().__init__(
+			bot,
+			config_prefix='patterns',
+			name='patterns',
+			short_description='Manages message pattern matching.',
+		)
 
 	def __get_patterns(self, guild: Guild) -> dict[str, PatternStatement]:
 		"""

rocketbot/cogs/urlspamcog.py

 from typing import Literal
 
 from discord import Member, Message, utils as discordutils
-from discord.ext import commands
+from discord.ext.commands import Cog
 from discord.utils import escape_markdown
 
 from config import CONFIG
 			brief='action to take on spam',
 			description='The action to take on detected URL spam.',
 			enum_values={'nothing', 'modwarn', 'delete', 'kick', 'ban'})
-	SETTING_JOIN_AGE = CogSetting('joinage', float,
+	SETTING_JOIN_AGE = CogSetting('joinage', timedelta,
 			brief='seconds since member joined',
 			description='The minimum seconds since the user joined the ' + \
 				'server before they can post URLs. URLs posted by users ' + \
 				'chatwarn', 'chatwarndelete', 'delete', 'kick', 'ban'})
 
 	def __init__(self, bot):
-		super().__init__(bot, 'urlspam')
+		super().__init__(
+			bot,
+			config_prefix='urlspam',
+			name='URL spam',
+			short_description='Manages URL spam detection.',
+		)
 		self.add_setting(URLSpamCog.SETTING_ENABLED)
 		self.add_setting(URLSpamCog.SETTING_ACTION)
 		self.add_setting(URLSpamCog.SETTING_JOIN_AGE)
 		self.add_setting(URLSpamCog.SETTING_DECEPTIVE_ACTION)
 
-	@commands.group(
-		brief='Manages URL spam detection',
-	)
-	@commands.has_permissions(ban_members=True)
-	@commands.guild_only()
-	async def urlspam(self, context: commands.Context):
-		"""URL spam command group"""
-		if context.invoked_subcommand is None:
-			await context.send_help()
-
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_message(self, message: Message):
 		"""Event listener"""
 		if message.author is None or \
 					return True
 		return False
 
-	def is_url(self, s: str):
+	def is_url(self, s: str) -> bool:
 		"""Tests if a string is strictly a URL"""
 		ipv6_host_pattern = r'\[[0-9a-fA-F:]+\]'
 		ipv4_host_pattern = r'[0-9\.]+'
 		pattern = r'^http[s]?://' + host_pattern + port_pattern + path_pattern + '$'
 		return re.match(pattern, s, re.IGNORECASE) is not None
 
-	def is_casual_url(self, s: str):
+	def is_casual_url(self, s: str) -> bool:
 		"""Tests if a string is a "casual URL" with no scheme included"""
 		ipv6_host_pattern = r'\[[0-9a-fA-F:]+\]'
 		ipv4_host_pattern = r'[0-9\.]+'

rocketbot/cogs/usernamecog.py

 """
 from typing import Optional
 
-from discord import Guild, Member
-from discord.ext import commands
+from discord import Guild, Member, Permissions, Interaction
+from discord.app_commands import Group
+from discord.ext.commands import Cog
 
 from config import CONFIG
 from rocketbot.cogs.basecog import BaseCog, BotMessage, BotMessageReaction, CogSetting
 	SETTING_PATTERNS = CogSetting('patterns', None)
 
 	def __init__(self, bot):
-		super().__init__(bot, 'username')
+		super().__init__(
+			bot,
+			config_prefix='username',
+			name='username patterns',
+			short_description='Manages username pattern detection.',
+		)
 		self.add_setting(UsernamePatternCog.SETTING_ENABLED)
 
 	def __get_patterns(self, guild: Guild) -> list[str]:
 		"""
 		cls.set_guild_setting(guild, cls.SETTING_PATTERNS, patterns)
 
-	@commands.group(
-		brief='Manages username pattern detection'
+	username = Group(
+		name='username',
+		description='Manages username pattern detection.',
+		guild_only=True,
+		default_permissions=Permissions(Permissions.manage_messages.flag),
 	)
-	@commands.has_permissions(ban_members=True)
-	@commands.guild_only()
-	async def username(self, context: commands.Context):
-		"""Username pattern command group"""
-		if context.invoked_subcommand is None:
-			await context.send_help()
 
 	@username.command(
-		brief='Adds a username pattern',
-		description='Adds a username pattern.',
-		usage='<pattern>'
+		description='Adds a username pattern',
+		extras={
+			'long_description': 'Adds a username pattern.',
+			'usage': '<pattern>',
+		},
 	)
-	async def add(self, context: commands.Context, pattern: str) -> None:
+	async def add(self, interaction: Interaction, pattern: str) -> None:
 		"""Command handler"""
 		norm_pattern = pattern.lower()
-		patterns: list[str] = self.__get_patterns(context.guild)
+		patterns: list[str] = self.__get_patterns(interaction.guild)
 		if norm_pattern in patterns:
-			await context.reply(f'Pattern `{norm_pattern}` already added.', mention_author=False)
+			await interaction.response.send_message(
+				f'Pattern `{norm_pattern}` already added.',
+				ephemeral=True
+			)
 			return
 		patterns.append(norm_pattern)
-		self.__save_patterns(context.guild, patterns)
-		await context.reply(f'Pattern `{norm_pattern}` added.', mention_author=False)
+		self.__save_patterns(interaction.guild, patterns)
+		await interaction.response.send_message(
+			f'Pattern `{norm_pattern}` added.',
+			ephemeral=True
+		)
 
 	@username.command(
-		brief='Removes a username pattern',
-		description='Removes an existing username pattern',
-		usage='<pattern>'
+		description='Removes a username pattern',
+		extras={
+			'long_description': 'Removes an existing username pattern',
+			'usage': '<pattern>',
+		},
 	)
-	async def remove(self, context: commands.Context, pattern: str) -> None:
+	async def remove(self, interaction: Interaction, pattern: str) -> None:
 		"""Command handler"""
 		norm_pattern = pattern.lower()
-		guild: Guild = context.guild
+		guild: Guild = interaction.guild
 		patterns: list[str] = self.__get_patterns(guild)
 		len_before = len(patterns)
 		patterns = list(filter(lambda p: p != norm_pattern, patterns))
 		if len(patterns) == len_before:
-			await context.reply(f'Pattern `{norm_pattern}` not found.', mention_author=False)
+			await interaction.response.send_message(
+				f'Pattern `{norm_pattern}` not found.',
+				ephemeral=True,
+			)
 			return
 		self.__save_patterns(guild, patterns)
-		await context.reply(f'Pattern `{norm_pattern}` removed.', mention_author=False)
+		await interaction.response.send_message(
+			f'Pattern `{norm_pattern}` removed.',
+			ephemeral=True,
+		)
 
 	@username.command(
-		brief='Lists username patterns'
+		description='Lists username patterns'
 	)
-	async def list(self, context: commands.Context) -> None:
+	async def list(self, interaction: Interaction) -> None:
 		"""Command handler"""
-		guild: Guild = context.guild
+		guild: Guild = interaction.guild
 		patterns: list[str] = self.__get_patterns(guild)
 		if len(patterns) == 0:
-			await context.reply('No patterns defined', mention_author=False)
+			await interaction.response.send_message(
+				'No patterns defined',
+				ephemeral=True,
+			)
 		else:
 			msg = 'Patterns:\n\n> `' + '`\n> `'.join(patterns) + '`'
-			await context.reply(msg, mention_author=False)
+			await interaction.response.send_message(
+				msg,
+				ephemeral=True,
+			)
 
-	@commands.Cog.listener()
+	@Cog.listener()
 	async def on_member_join(self, member: Member) -> None:
 		"""Event handler"""
 		for pattern in self.__get_patterns(member.guild):

rocketbot/cogsetting.py

 """
 A guild configuration setting available for editing via bot commands.
 """
-import inspect
-from typing import Any, Optional, Type, TypeVar, Coroutine, Literal
+from datetime import timedelta
+from typing import Any, Optional, Type, TypeVar, Literal
 
-from discord import Interaction, Permissions, permissions
-from discord.app_commands import Range, guild_only, default_permissions
+from discord import Interaction, Permissions
+from discord.app_commands import Range, Transform
 from discord.app_commands.commands import Command, Group, CommandCallback
 from discord.ext.commands import Bot
 
 from config import CONFIG
 from rocketbot.storage import Storage
-from rocketbot.utils import bot_log
+from rocketbot.utils import bot_log, TimeDeltaTransformer
 
 # def _fix_command(command: Command) -> None:
 # 	"""
 				)
 		setattr(cog.__class__, f'_cmd_get_{setting.name}', getter)
 		getter.__qualname__ = f'{self.__class__.__name__}._cmd_get_{setting.name}'
+		getter.__self__ = cog
 		bot_log(None, cog.__class__, f"Creating /get {setting_name}")
 		command = Command(
 			name=setting_name,
-			description=f'Shows value of {setting_name}',
+			description=f'Shows {self.brief}.',
 			callback=getter,
 			parent=CogSetting.__get_group,
 		)
 				ephemeral=True
 			)
 			await self.on_setting_updated(interaction.guild, setting)
-			self.log(interaction.guild, f'{interaction.message.author.name} set {key} to {new_value}')
+			self.log(interaction.guild, f'{interaction.user.name} set {key} to {new_value}')
 
-		type_str: str = 'any'
 		setter: CommandCallback = setter_general
 		if self.datatype == int:
 			if self.min_value is not None or self.max_value is not None:
-				type_str = f'discord.app_commands.Range[int, {self.min_value}, {self.max_value}]'
 				r_min = self.min_value
 				r_max = self.max_value
 				async def setter_range(self, interaction: Interaction, new_value: Range[int, r_min, r_max]) -> None:
 					await self.setter_general(interaction, new_value)
 				setter = setter_range
 			else:
-				type_str = 'int'
 				async def setter_int(self, interaction: Interaction, new_value: int) -> None:
 					await self.setter_general(interaction, new_value)
 				setter = setter_int
 		elif self.datatype == float:
-			type_str = 'float'
 			async def setter_float(self, interaction: Interaction, new_value: float) -> None:
 				await self.setter_general(interaction, new_value)
 			setter = setter_float
+		elif self.datatype == timedelta:
+			async def setter_timedelta(self, interaction: Interaction, new_value: Transform[timedelta, TimeDeltaTransformer]) -> None:
+				await self.setter_general(interaction, new_value)
+			setter = setter_timedelta
 		elif getattr(self.datatype, '__origin__', None) == Literal:
-			value_list = '"' + '", "'.join(self.enum_values) + '"'
-			type_str = f'typing.Literal[{value_list}]'
-			values = self.enum_values
 			dt = self.datatype
 			async def setter_enum(self, interaction: Interaction, new_value: dt) -> None:
 				await self.setter_general(interaction, new_value)
-
 			setter = setter_enum
 		elif self.datatype == str:
 			if self.enum_values is not None:
 				raise ValueError('Type for a setting with enum values should be typing.Literal')
 			else:
-				type_str = 'str'
 				async def setter_str(self, interaction: Interaction, new_value: str) -> None:
 					await self.setter_general(interaction, new_value)
 				setter = setter_str
 		elif setting.datatype == bool:
-			type_str = f'bool'
 			async def setter_bool(self, interaction: Interaction, new_value: bool) -> None:
 				await self.setter_general(interaction, new_value)
 			setter = setter_bool
 			raise ValueError(f'Invalid type {self.datatype}')
 		setattr(cog.__class__, f'_cmd_set_{setting.name}', setter)
 		setter.__qualname__ = f'{cog.__class__.__name__}._cmd_set_{setting.name}'
-		bot_log(None, cog.__class__, f"Creating /set {setting_name} {type_str}")
+		setter.__self__ = cog
+		bot_log(None, cog.__class__, f"Creating /set {setting_name} {self.datatype}")
 		command = Command(
 			name=setting_name,
-			description=f'Sets value of {setting_name}',
+			description=f'Sets {self.brief}.',
 			callback=setter,
 			parent=CogSetting.__set_group,
 		)
 
 	def __make_enable_command(self, cog: BaseCog) -> Command:
 		setting: CogSetting = self
-		async def enabler(self, interaction: Interaction) -> None:
+		async def enabler(self: BaseCog, interaction: Interaction) -> None:
 			print(f"invoking enable for {self.config_prefix}")
 			key = f'{self.__class__.__name__}.{setting.name}'
 			Storage.set_config_value(interaction.guild, key, True)
 				ephemeral=True
 			)
 			await self.on_setting_updated(interaction.guild, setting)
-			self.log(interaction.guild, f'{interaction.message.author.name} enabled {self.__class__.__name__}')
+			self.log(interaction.guild, f'{interaction.user.name} enabled {self.__class__.__name__}')
 		setattr(cog.__class__, f'_cmd_enable', enabler)
 		enabler.__qualname__ = f'{cog.__class__.__name__}._cmd_enable'
+		enabler.__self__ = cog
 		bot_log(None, cog.__class__, f"Creating /enable {cog.config_prefix}")
 
 		command = Command(
 
 	def __make_disable_command(self, cog: BaseCog) -> Command:
 		setting: CogSetting = self
-		async def disabler(self, interaction: Interaction) -> None:
+		async def disabler(self: BaseCog, interaction: Interaction) -> None:
 			print(f"invoking disable for {self.config_prefix}")
 			key = f'{self.__class__.__name__}.{setting.name}'
 			Storage.set_config_value(interaction.guild, key, False)
 				ephemeral=True
 			)
 			await self.on_setting_updated(interaction.guild, setting)
-			self.log(interaction.guild, f'{interaction.message.author.name} disabled {self.__class__.__name__}')
+			self.log(interaction.guild, f'{interaction.user.name} disabled {self.__class__.__name__}')
 		setattr(cog.__class__, f'_cmd_disable', disabler)
 		disabler.__qualname__ = f'{cog.__class__.__name__}._cmd_disable'
+		disabler.__self__ = cog
 		bot_log(None, cog.__class__, f"Creating /disable {cog.config_prefix}")
 
 		command = Command(
 		)
 		cls.__enable_group = Group(
 			name='enable',
-			description='Enables a set of bot functionality for this guild',
+			description='Enables bot functionality for this guild',
 			default_permissions=cls.permissions
 		)
 		cls.__disable_group = Group(
 			name='disable',
-			description='Disables a set of bot functionality for this guild',
+			description='Disables bot functionality for this guild',
 			default_permissions=cls.permissions
 		)
 		bot.tree.add_command(cls.__set_group)

rocketbot/utils.py

 
 def timedelta_from_str(s: str) -> timedelta:
 	"""
-	Parses a timespan. Format examples:
+	Parses a timespan.
+
+	Format examples:
 	"30m"
 	"10s"
 	"90d"
 	"1h30m"
 	"73d18h22m52s"
+
+	Parameters
+	----------
+	s : str
+		string to parse
+
+	Returns
+	-------
+	timedelta
+
+	Raises
+	------
+	ValueError
+		if parsing fails
 	"""
-	p: re.Pattern = re.compile('^(?:[0-9]+[dhms])+$')
+	p: re.Pattern = re.compile('^(?:[0-9]+[a-zA-Z])+$')
 	if p.match(s) is None:
-		raise ValueError("Illegal timespan value '{s}'.")
+		raise ValueError(f'Illegal timespan value "{s}". Examples: 30s, 5m, 1h30m, 30d')
 	p = re.compile('([0-9]+)([dhms])')
 	days: int = 0
 	hours: int = 0
 	seconds: int = 0
 	for m in p.finditer(s):
 		scalar = int(m.group(1))
-		unit = m.group(2)
+		unit = m.group(2).lower()
 		if unit == 'd':
 			days = scalar
 		elif unit == 'h':
 			minutes = scalar
 		elif unit == 's':
 			seconds = scalar
+		else:
+			raise ValueError(f'Invalid unit "{unit}". Valid units: "s"=seconds, "m"=minutes, "h"=hours, "d"=days')
 	return timedelta(days=days, hours=hours, minutes=minutes, seconds=seconds)
 
 def str_from_timedelta(td: timedelta) -> str:
 	if len(val) < 2 or val[0:1] not in __QUOTE_CHARS or val[-1:] not in __QUOTE_CHARS:
 		raise ValueError(f'Not a quoted string: {val}')
 	return val[1:-1]
+
+from discord import Interaction
+from discord.app_commands import Transformer
+from discord.ext.commands import BadArgument
+
+class TimeDeltaTransformer(Transformer):
+	async def transform(self, interaction: Interaction, value: Any) -> timedelta:
+		try:
+			return timedelta_from_str(str(value))
+		except ValueError as e:
+			print("Invalid time delta:", e)
+			raise BadArgument(str(e))
+
+	@property
+	def _error_display_name(self) -> str:
+		return 'timedelta'