Lots of help refinements

rocketbot/cogs/autokickcog.py

 		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)

rocketbot/cogs/basecog.py

 			self,
 			bot: Rocketbot,
 			config_prefix: Optional[str],
-			name: str,
 			short_description: str,
 			long_description: Optional[str] = None,
 	):
 		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
 

rocketbot/cogs/configcog.py

 		super().__init__(
 			bot,
 			config_prefix='config',
-			name='configuration',
 			short_description='Manages general bot configuration.',
 		)
 
 	config = Group(
 		name='config',
-		description='Manages general bot configuration',
+		description='Manages general bot configuration.',
 		guild_only=True,
 		default_permissions=MOD_PERMISSIONS,
 	)

rocketbot/cogs/crosspostcog.py

 			'when looking for duplicates. Shorter values are preferred, ' + \
 			'both to detect bots and avoid excessive memory usage.',
 		usage='<seconds:int>',
-		min_value=1)
+		min_value=timedelta(seconds=1))
 
 	STATE_KEY_RECENT_MESSAGES = "CrossPostCog.recent_messages"
 	STATE_KEY_SPAM_CONTEXT = "CrossPostCog.spam_context"
 		super().__init__(
 			bot,
 			config_prefix='crosspost',
-			name='crosspost detection',
 			short_description='Manages crosspost detection and handling.',
 		)
 		self.add_setting(CrossPostCog.SETTING_ENABLED)

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, Union
 
-from discord import Interaction, Message, User, Permissions
-from discord.app_commands import Command, Group, command, default_permissions, guild_only, Transform, rename, Choice, \
+from discord import Interaction, Message, User, Permissions, AppCommandType
+from discord.app_commands import Command, Group, command, default_permissions, guild_only, Transform, Choice, \
 	autocomplete
 from discord.errors import DiscordException
 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 describe_timedelta, TimeDeltaTransformer, dump_stacktrace
+from rocketbot.utils import describe_timedelta, TimeDeltaTransformer, dump_stacktrace, MOD_PERMISSIONS
 from rocketbot.storage import ConfigKey, Storage
 
+
+trivial_words = {
+	'a', 'an', 'and', 'are', "aren't", 'as', 'by', 'can', 'for', 'have', 'if', 'in',
+	'is', 'it', 'its', "it's", 'not', 'of', 'on', 'or', 'than', 'that', 'the', 'then',
+	'there', 'them', 'they', "they're", 'this', 'to', 'when', 'with',
+}
+
 async def command_autocomplete(interaction: Interaction, current: str) -> list[Choice[str]]:
 	choices: list[Choice] = []
 	try:
 		user_permissions = interaction.permissions
 		cmds = GeneralCog.shared.get_command_list(user_permissions)
 		return [
-			Choice(name=f'/{cmdname}', value=f'/{cmdname}')
+			Choice(name=f'/{cmdname} command', value=f'cmd:{cmdname}')
 			for cmdname in sorted(cmds.keys())
-			if len(current) == 0 or cmdname.startswith(current)
-		]
+			if len(current) == 0 or current in cmdname
+		][:25]
 	except BaseException as e:
 		dump_stacktrace(e)
 	return choices
 async def subcommand_autocomplete(interaction: Interaction, current: str) -> list[Choice[str]]:
 	try:
 		current = current.lower().strip()
-		cmd_name = interaction.namespace['command']
-		if cmd_name.startswith('/'):
-			cmd_name = cmd_name[1:]
+		cmd_name = interaction.namespace['topic']
+		cmd = GeneralCog.shared.object_for_help_symbol(cmd_name)
+		if not isinstance(cmd, Group):
+			return []
 		user_permissions = interaction.permissions
-		cmd = GeneralCog.shared.get_command_list(user_permissions).get(cmd_name)
 		if cmd is None or not isinstance(cmd, Group):
 			print(f'No command found named {cmd_name}')
 			return []
 			print(f'Subcommands for {cmd_name} was None')
 			return []
 		return [
-			Choice(name=subcmd_name, value=subcmd_name)
+			Choice(name=f'{subcmd_name} subcommand', value=f'subcmd:{cmd_name}.{subcmd_name}')
 			for subcmd_name in sorted(subcmds.keys())
-			if len(current) == 0 or subcmd_name.startswith(current)
+			if len(current) == 0 or current in subcmd_name
+		][:25]
+	except BaseException as e:
+		dump_stacktrace(e)
+	return []
+
+async def cog_autocomplete(interaction: Interaction, current: str) -> list[Choice[str]]:
+	try:
+		current = current.lower().strip()
+		return [
+			Choice(name=f'⚙ {cog.qualified_name} module', value=f'cog:{cog.qualified_name}')
+			for cog in sorted(GeneralCog.shared.bot.cogs.values(), key=lambda c: c.qualified_name)
+			if isinstance(cog, BaseCog) and
+			   can_use_cog(cog, interaction.permissions) and
+			   (len(cog.get_commands()) > 0 or len(cog.settings) > 0) and \
+			   (len(current) == 0 or current in cog.qualified_name.lower())
 		]
 	except BaseException as e:
 		dump_stacktrace(e)
 	return []
 
+async def topic_autocomplete(interaction: Interaction, current: str) -> list[Choice[str]]:
+	command_choices = await command_autocomplete(interaction, current)
+	cog_choices = await cog_autocomplete(interaction, current)
+	return (command_choices + cog_choices)[:25]
+
+async def subtopic_autocomplete(interaction: Interaction, current: str) -> list[Choice[str]]:
+	subcommand_choices = await subcommand_autocomplete(interaction, current)
+	return subcommand_choices[:25]
+
 def can_use_command(cmd: Union[Group, Command], user_permissions: Optional[Permissions]) -> bool:
-	return user_permissions is not None and \
-		(cmd.default_permissions is None or cmd.default_permissions.is_subset(user_permissions))
+	if user_permissions is None:
+		return False
+	if cmd.parent and not can_use_command(cmd.parent, user_permissions):
+		return False
+	return cmd.default_permissions is None or cmd.default_permissions.is_subset(user_permissions)
+
+def can_use_cog(cog: BaseCog, user_permissions: Optional[Permissions]) -> bool:
+	return user_permissions is not None and MOD_PERMISSIONS.is_subset(user_permissions)
 
 class GeneralCog(BaseCog, name='General'):
 	"""
 		super().__init__(
 			bot,
 			config_prefix=None,
-			name='',
 			short_description='',
 		)
 		self.is_connected = False
 			ephemeral=True,
 		)
 
+	def __create_help_index(self) -> None:
+		if getattr(self, 'obj_index', None) is not None:
+			return
+		self.obj_index: dict[str, Union[Command, Group, BaseCog]] = {}
+		self.keyword_index: dict[str, set[Union[Command, Group, BaseCog]]] = {}
+
+		def add_text_to_index(obj, text: str):
+			words = [
+				word
+				for word in re.split(r"[^a-zA-Z']+", text.lower())
+				if len(word) > 1 and word not in trivial_words
+			]
+			for word in words:
+				matches = self.keyword_index.get(word, set())
+				matches.add(obj)
+				self.keyword_index[word] = matches
+
+		for cmd in self.bot.tree.get_commands(type=AppCommandType.chat_input):
+			key = f'cmd:{cmd.name}'
+			self.obj_index[key] = cmd
+			add_text_to_index(cmd, cmd.name)
+			if cmd.description:
+				add_text_to_index(cmd, cmd.description)
+			if isinstance(cmd, Group):
+				for subcmd in cmd.commands:
+					key = f'subcmd:{cmd.name}.{subcmd.name}'
+					self.obj_index[key] = subcmd
+					add_text_to_index(subcmd, subcmd.name)
+					if subcmd.description:
+						add_text_to_index(subcmd, subcmd.description)
+		for cog_qname, cog in self.bot.cogs.items():
+			if not isinstance(cog, BaseCog):
+				continue
+			key = f'cog:{cog_qname}'
+			self.obj_index[key] = cog
+			add_text_to_index(cog, cog.qualified_name)
+			if cog.description:
+				add_text_to_index(cog, cog.description)
+		print(self.obj_index.keys())
+		print(self.keyword_index.keys())
+
+	def object_for_help_symbol(self, symbol: str) -> Optional[Union[Command, Group, BaseCog]]:
+		self.__create_help_index()
+		return self.obj_index.get(symbol, None)
+
 	@command(name='help')
 	@guild_only()
-	@rename(command_name='command', subcommand_name='subcommand')
-	@autocomplete(command_name=command_autocomplete, subcommand_name=subcommand_autocomplete)
-	async def help_command(self, interaction: Interaction, command_name: Optional[str] = None, subcommand_name: Optional[str] = None) -> None:
+	@autocomplete(topic=topic_autocomplete, subtopic=subtopic_autocomplete)
+	async def help_command(self, interaction: Interaction, topic: Optional[str] = None, subtopic: Optional[str] = None) -> None:
 		"""
-		Shows help for using commands and subcommands.
+		Shows help for using commands and subcommands and configuring modules.
 
-		`/help` will show a list of top-level commands.
+		`/help` will show a list of top-level topics.
 
 		`/help /<command_name>` will show help about a specific command or
 		list a command's subcommands.
 		`/help /<command_name> <subcommand_name>` will show help about a
 		specific subcommand.
 
+		`/help <module_name>` will show help about configuring a module.
+
+		`/help <keywords>` will do a text search for topics.
+
 		Parameters
 		----------
 		interaction: Interaction
-		command_name: Optional[str]
-			Optional name of a command to get specific help for. With or without the leading slash.
-		subcommand_name: Optional[str]
-			Optional name of a subcommand to get specific help for.
+		topic: Optional[str]
+			Optional topic to get specific help for. Getting help on a command can optionally start with a leading slash.
+		subtopic: Optional[str]
+			Optional subtopic to get specific help for.
 		"""
-		print(f'help_command(interaction, {command_name}, {subcommand_name})')
-		cmds: list[Command] = self.bot.tree.get_commands()
-		if command_name is None:
+		print(f'help_command(interaction, {topic}, {subtopic})')
+
+		# General help
+		if topic is None:
 			await self.__send_general_help(interaction)
 			return
 
-		if command_name.startswith('/'):
-			command_name = command_name[1:]
-		cmd = next((c for c in cmds if c.name == command_name), None)
-		if cmd is None:
-			interaction.response.send_message(
-				f'Command `{command_name}` not found!',
-				ephemeral=True,
-			)
-			return
-		if subcommand_name is None:
-			await self.__send_command_help(interaction, cmd)
+		# Specific object reference
+		obj = self.object_for_help_symbol(subtopic) if subtopic else self.object_for_help_symbol(topic)
+		if obj:
+			await self.__send_object_help(interaction, obj)
 			return
 
-		if not isinstance(cmd, Group):
-			await self.__send_command_help(interaction, cmd, addendum=f'{CONFIG["warning_emoji"]} Command does not have subcommands. Showing help for base command.')
+		# Text search
+		keywords = [
+			word
+			for word in re.split(r"[^a-zA-Z']+", topic.lower())
+			if len(word) > 0 and word not in trivial_words
+		]
+		matching_objects_set = None
+		for keyword in keywords:
+			objs = self.keyword_index.get(keyword, None)
+			if objs is not None:
+				if matching_objects_set is None:
+					matching_objects_set = objs
+				else:
+					matching_objects_set = matching_objects_set & objs
+		accessible_objects = [
+			obj
+			for obj in matching_objects_set or {}
+			if ((isinstance(obj, Command) or isinstance(obj, Group)) and can_use_command(obj, interaction.permissions)) or \
+			   (isinstance(obj, BaseCog) and can_use_cog(obj, interaction.permissions))
+		]
+		await self.__send_keyword_help(interaction, accessible_objects)
+
+	async def __send_object_help(self, interaction: Interaction, obj: Union[Command, Group, BaseCog]) -> None:
+		if isinstance(obj, Command):
+			if obj.parent:
+				await self.__send_subcommand_help(interaction, obj.parent, obj)
+			else:
+				await self.__send_command_help(interaction, obj)
 			return
-		grp: Group = cmd
-		subcmd: Command = next((c for c in grp.commands if c.name == subcommand_name), None)
-		if subcmd is None:
-			await self.__send_command_help(interaction, cmd, addendum=f'{CONFIG["warning_emoji"]} Command `/{command_name}` does not have a subcommand "{subcommand_name}". Showing help for base command.')
+		if isinstance(obj, Group):
+			await self.__send_command_help(interaction, obj)
 			return
-		await self.__send_subcommand_help(interaction, grp, subcmd)
-		return
+		if isinstance(obj, BaseCog):
+			await self.__send_cog_help(interaction, obj)
+			return
+		print(f'No help for object {obj}')
+		await interaction.response.send_message(
+			f'{CONFIG["failure_emoji"]} Failed to get help info.',
+			ephemeral=True,
+			delete_after=10,
+		)
 
 	def get_command_list(self, permissions: Optional[Permissions] = None) -> dict[str, Union[Command, Group]]:
 		return { cmd.name: cmd for cmd in self.bot.tree.get_commands() if can_use_command(cmd, permissions) }
 
 	def get_subcommand_list(self, cmd: Group, permissions: Optional[Permissions] = None) -> dict[str, Command]:
-		return { subcmd.name: subcmd for subcmd in cmd.commands if can_use_command(subcmd, permissions) }
+		return {
+			subcmd.name: subcmd
+			for subcmd in cmd.commands
+			if can_use_command(subcmd, permissions)
+		} if can_use_command(cmd, permissions) else {}
 
 	async def __send_general_help(self, interaction: Interaction) -> None:
 		user_permissions: Permissions = interaction.permissions
-		text = f'## :information_source: Commands'
-		for cmd_name, cmd in sorted(self.get_command_list(user_permissions).items()):
-			text += f'\n- `/{cmd_name}`: {cmd.description}'
+		all_commands = sorted(self.get_command_list(user_permissions).items())
+		all_cog_tuples = [
+			cog_tuple
+			for cog_tuple in sorted(self.bot.cogs.items())
+			if isinstance(cog_tuple[1], BaseCog) and \
+			   can_use_cog(cog_tuple[1], user_permissions) and \
+			   (len(cog_tuple[1].settings) > 0)
+		]
+
+		text = f'## :information_source: Help'
+		if len(all_commands) + len(all_cog_tuples) == 0:
+			text = 'Nothing available for your permissions!'
+
+		if len(all_commands) > 0:
+			text += '\n### Commands'
+			text += '\nType `/help /commandname` for more information.'
+			for cmd_name, cmd in sorted(self.get_command_list(user_permissions).items()):
+				text += f'\n- `/{cmd_name}`: {cmd.description}'
+				if isinstance(cmd, Group):
+					subcommand_count = len(cmd.commands)
+					text += f' ({subcommand_count} subcommands)'
+
+		if len(all_cog_tuples) > 0:
+			text += '\n### Module Configuration'
+			for cog_name, cog in all_cog_tuples:
+				has_enabled = next((s for s in cog.settings if s.name == 'enabled'), None) is not None
+				text += f'\n- **{cog_name}**: {cog.short_description}'
+				if has_enabled:
+					text += f'\n   - `/enable {cog.config_prefix}` or `/disable {cog.config_prefix}`'
+				for setting in cog.settings:
+					if setting.name == 'enabled':
+						continue
+					text += f'\n   - `/get` or `/set {cog.config_prefix}_{setting.name}`'
+		await interaction.response.send_message(
+			text,
+			ephemeral=True,
+		)
+
+	async def __send_keyword_help(self, interaction: Interaction, matching_objects: Optional[list[Union[Command, Group, BaseCog]]]) -> None:
+		matching_commands = [
+			cmd
+			for cmd in matching_objects or []
+			if isinstance(cmd, Command) or isinstance(cmd, Group)
+		]
+		matching_cogs = [
+			cog
+			for cog in matching_objects or []
+			if isinstance(cog, BaseCog)
+		]
+		if len(matching_commands) + len(matching_cogs) == 0:
+			await interaction.response.send_message(
+				f'{CONFIG["failure_emoji"]} No available help topics found.',
+				ephemeral=True,
+				delete_after=10,
+			)
+			return
+		if len(matching_objects) == 1:
+			obj = matching_objects[0]
+			await self.__send_object_help(interaction, obj)
+			return
+
+		text = '## :information_source: Matching Help Topics'
+		if len(matching_commands) > 0:
+			text += '\n### Commands'
+			for cmd in matching_commands:
+				if cmd.parent:
+					text += f'\n- `/{cmd.parent.name} {cmd.name}`'
+				else:
+					text += f'\n- `/{cmd.name}`'
+		if len(matching_cogs) > 0:
+			text += '\n### Cogs'
+			for cog in matching_cogs:
+				text += f'\n- {cog.qualified_name}'
 		await interaction.response.send_message(
 			text,
 			ephemeral=True,
 			for param in params:
 				text += f'\n- `{param.name}`: {param.description}'
 		await interaction.response.send_message(text, ephemeral=True)
+
+	async def __send_cog_help(self, interaction: Interaction, cog: BaseCog) -> None:
+		text = f'## :information_source: Module Help\n{cog.qualified_name}'
+		if cog.description is not None:
+			text += f'\n{cog.description}'
+		settings = cog.settings
+		if len(settings) > 0:
+			text += '\n### Configuration'
+			enabled_setting = next((s for s in settings if s.name == 'enabled'), None)
+			if enabled_setting is not None:
+				text += f'\n- `/enable {cog.config_prefix}` or `/disable {cog.config_prefix}`'
+			for setting in sorted(settings, key=lambda s: s.name):
+				if setting.name == 'enabled':
+					continue
+				text += f'\n- `/get` or `/set {cog.config_prefix}_{setting.name}` - {setting.description}'
+		await interaction.response.send_message(
+			text,
+			ephemeral=True,
+		)

rocketbot/cogs/joinraidcog.py

 				'at when counting recent joins. If joincount or more ' + \
 				'joins occur within jointime seconds a mod warning is issued.',
 			usage='<seconds:float>',
-			min_value=1.0,
-			max_value=900.0)
+			min_value=timedelta(seconds=1.0),
+			max_value=timedelta(seconds=900.0))
 
 	STATE_KEY_RECENT_JOINS = "JoinRaidCog.recent_joins"
 	STATE_KEY_LAST_RAID = "JoinRaidCog.last_raid"
 		super().__init__(
 			bot,
 			config_prefix='joinraid',
-			name='join raid',
 			short_description='Manages join raid detection and handling.',
 		)
 		self.add_setting(JoinRaidCog.SETTING_ENABLED)

rocketbot/cogs/logcog.py

 		super().__init__(
 			bot,
 			config_prefix='logging',
-			name='logging',
-			short_description='Manages event logging',
+			short_description='Manages event logging.',
 		)
 		self.add_setting(LoggingCog.SETTING_ENABLED)
 		self.flush_buffers.start()

rocketbot/cogs/patterncog.py

 		super().__init__(
 			bot,
 			config_prefix='patterns',
-			name='patterns',
 			short_description='Manages message pattern matching.',
 		)
 		PatternCog.shared = self

rocketbot/cogs/urlspamcog.py

 				'new members can say anything. Setting to 0 effectively ' + \
 				'disables URL spam detection.',
 			usage='<seconds:int>',
-			min_value=0)
+			min_value=timedelta(seconds=0))
 	SETTING_DECEPTIVE_ACTION = CogSetting('deceptiveaction', Literal['nothing', 'modwarn', 'modwarndelete', 'chatwarn', 'chatwarndelete', 'delete', 'kick', 'ban'],
 			brief='action to take on deceptive link markdown',
 			description='The action to take on chat messages with links ' + \
 		super().__init__(
 			bot,
 			config_prefix='urlspam',
-			name='URL spam',
 			short_description='Manages URL spam detection.',
 		)
 		self.add_setting(URLSpamCog.SETTING_ENABLED)

rocketbot/cogs/usernamecog.py

 		super().__init__(
 			bot,
 			config_prefix='username',
-			name='username patterns',
 			short_description='Manages username pattern detection.',
 		)
 		self.add_setting(UsernamePatternCog.SETTING_ENABLED)

rocketbot/cogsetting.py

 from typing import Any, Optional, Type, TypeVar, Literal
 
 from discord import Interaction, Permissions
-from discord.app_commands import Range, Transform
-from discord.app_commands.commands import Command, Group, CommandCallback
+from discord.app_commands import Range, Transform, describe
+from discord.app_commands.commands import Command, Group, CommandCallback, rename
 from discord.ext.commands import Bot
 
 from config import CONFIG
 from rocketbot.storage import Storage
-from rocketbot.utils import bot_log, TimeDeltaTransformer
+from rocketbot.utils import bot_log, TimeDeltaTransformer, MOD_PERMISSIONS
 
 # def _fix_command(command: Command) -> None:
 # 	"""
 		self.min_value: Optional[Any] = min_value
 		self.max_value: Optional[Any] = max_value
 		self.enum_values: Optional[set[Any]] = enum_values
-		if self.enum_values or self.min_value is not None or self.max_value is not None:
-			self.description += '\n'
 		if self.enum_values:
-			allowed_values = '`' + ('`, `'.join(enum_values)) + '`'
-			self.description += f'\nAllowed values: {allowed_values}'
-		if self.min_value is not None:
-			self.description += f'\nMin value: {self.min_value}'
-		if self.max_value is not None:
-			self.description += f'\nMax value: {self.max_value}'
-		if self.usage is None:
-			self.usage = f'<{self.name}>'
+			value_list = '`' + ('`, `'.join(self.enum_values)) + '`'
+			self.description += f' (Permitted values: {value_list})'
+		elif self.min_value is not None and self.max_value is not None:
+			self.description += f' (Value must be between `{self.min_value}` and `{self.max_value}`)'
+		elif self.min_value is not None:
+			self.description += f' (Minimum value: {self.min_value})'
+		elif self.max_value is not None:
+			self.description += f' (Maximum value: {self.max_value})'
 
 	def validate_value(self, new_value: Any) -> None:
 		"""
 			self.__get_group.add_command(self.__make_getter_command(cog))
 			self.__set_group.add_command(self.__make_setter_command(cog))
 
+	def to_stored_value(self, native_value: Any) -> Any:
+		if self.datatype is timedelta:
+			return native_value.total_seconds()
+		return native_value
+
+	def to_native_value(self, stored_value: Any) -> Any:
+		if self.datatype is timedelta:
+			return timedelta(seconds=stored_value)
+		return stored_value
+
 	def __make_getter_command(self, cog: BaseCog) -> Command:
 		setting: CogSetting = self
 		setting_name = setting.name
 		if cog.config_prefix is not None:
 			setting_name = f'{cog.config_prefix}_{setting_name}'
-		async def getter(self, interaction: Interaction) -> None:
+		datatype = self.datatype
+		async def getter(cog0, interaction: Interaction) -> None:
 			print(f"invoking getter for {setting_name}")
-			key = f'{self.__class__.__name__}.{setting.name}'
-			value = Storage.get_config_value(interaction.guild, key)
+			key = f'{cog0.__class__.__name__}.{setting.name}'
+			value = setting.to_native_value(Storage.get_config_value(interaction.guild, key))
 			if value is None:
-				value = self.get_cog_default(setting.name)
+				value = setting.to_native_value(cog0.get_cog_default(setting.name))
 				await interaction.response.send_message(
 					f'{CONFIG["info_emoji"]} `{setting_name}` is using default of `{value}`',
 					ephemeral=True
 					f'{CONFIG["info_emoji"]} `{setting_name}` is set to `{value}`',
 					ephemeral=True
 				)
-		setattr(cog.__class__, f'_cmd_get_{setting.name}', getter)
-		getter.__qualname__ = f'{self.__class__.__name__}._cmd_get_{setting.name}'
-		getter.__self__ = cog
+
+		# We have to do some surgery to make the getter function a proper method on the cog
+		# that discord.py will recognize and wire up correctly. Same for other accessors below.
+		setattr(cog.__class__, f'_cmd_get_{setting.name}', getter)  # add method to cog class
+		getter.__qualname__ = f'{self.__class__.__name__}._cmd_get_{setting.name}'  # discord.py checks this to know if it's a method vs function
+		getter.__self__ = cog  # discord.py uses this as the self argument
+
 		bot_log(None, cog.__class__, f"Creating /get {setting_name}")
 		command = Command(
 			name=setting_name,
 			description=f'Shows {self.brief}.',
 			callback=getter,
 			parent=CogSetting.__get_group,
+			extras={
+				'cog': cog,
+				'setting': setting,
+				'long_description': setting.description,
+			},
 		)
 		return command
 
 				)
 				return
 			key = f'{self.__class__.__name__}.{setting.name}'
-			Storage.set_config_value(interaction.guild, key, new_value)
+			Storage.set_config_value(interaction.guild, key, setting.to_stored_value(new_value))
 			await interaction.response.send_message(
 				f'{CONFIG["success_emoji"]} `{setting_name}` is now set to `{new_value}`',
 				ephemeral=True
 			if self.min_value is not None or self.max_value is not None:
 				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)
+				@rename(new_value=self.name)
+				@describe(new_value=self.brief)
+				async def setter_range(cog0, interaction: Interaction, new_value: Range[int, r_min, r_max]) -> None:
+					await setter_general(cog0, interaction, new_value)
 				setter = setter_range
 			else:
-				async def setter_int(self, interaction: Interaction, new_value: int) -> None:
-					await self.setter_general(interaction, new_value)
+				@rename(new_value=self.name)
+				@describe(new_value=self.brief)
+				async def setter_int(cog0, interaction: Interaction, new_value: int) -> None:
+					await setter_general(cog0, interaction, new_value)
 				setter = setter_int
 		elif self.datatype == float:
-			async def setter_float(self, interaction: Interaction, new_value: float) -> None:
-				await self.setter_general(interaction, new_value)
+			@rename(new_value=self.name)
+			@describe(new_value=self.brief)
+			async def setter_float(cog0, interaction: Interaction, new_value: float) -> None:
+				await setter_general(cog0, 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)
+			@rename(new_value=self.name)
+			@describe(new_value=f'{self.brief} (e.g. 30s, 5m, 1h30s, or 7d)')
+			async def setter_timedelta(cog0, interaction: Interaction, new_value: Transform[timedelta, TimeDeltaTransformer]) -> None:
+				await setter_general(cog0, interaction, new_value)
 			setter = setter_timedelta
 		elif getattr(self.datatype, '__origin__', None) == Literal:
 			dt = self.datatype
-			async def setter_enum(self, interaction: Interaction, new_value: dt) -> None:
-				await self.setter_general(interaction, new_value)
+			@rename(new_value=self.name)
+			@describe(new_value=self.brief)
+			async def setter_enum(cog0, interaction: Interaction, new_value: dt) -> None:
+				await setter_general(cog0, 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:
-				async def setter_str(self, interaction: Interaction, new_value: str) -> None:
-					await self.setter_general(interaction, new_value)
+				@rename(new_value=self.name)
+				@describe(new_value=self.brief)
+				async def setter_str(cog0, interaction: Interaction, new_value: str) -> None:
+					await setter_general(cog0, interaction, new_value)
 				setter = setter_str
 		elif setting.datatype == bool:
-			async def setter_bool(self, interaction: Interaction, new_value: bool) -> None:
-				await self.setter_general(interaction, new_value)
+			@rename(new_value=self.name)
+			@describe(new_value=self.brief)
+			async def setter_bool(cog0, interaction: Interaction, new_value: bool) -> None:
+				await setter_general(cog0, interaction, new_value)
 			setter = setter_bool
 		elif setting.datatype is not None:
 			raise ValueError(f'Invalid type {self.datatype}')
 			description=f'Sets {self.brief}.',
 			callback=setter,
 			parent=CogSetting.__set_group,
+			extras={
+				'cog': cog,
+				'setting': setting,
+				'long_description': setting.description,
+			},
 		)
-		# HACK: Passing `cog` in init gets ignored and set to `None` so set after.
-		# This ensures the callback is passed the cog as `self` argument.
-		# command.cog = cog
-		# _fix_command(command)
 		return command
 
 	def __make_enable_command(self, cog: BaseCog) -> Command:
 		setting: CogSetting = self
-		async def enabler(self: BaseCog, interaction: Interaction) -> None:
-			print(f"invoking enable for {self.config_prefix}")
-			key = f'{self.__class__.__name__}.{setting.name}'
+		async def enabler(cog0: BaseCog, interaction: Interaction) -> None:
+			print(f"invoking enable for {cog0.config_prefix}")
+			key = f'{cog0.__class__.__name__}.{setting.name}'
 			Storage.set_config_value(interaction.guild, key, True)
 			await interaction.response.send_message(
 				f'{CONFIG["success_emoji"]} {setting.brief.capitalize()} enabled.',
 				ephemeral=True
 			)
-			await self.on_setting_updated(interaction.guild, setting)
-			self.log(interaction.guild, f'{interaction.user.name} enabled {self.__class__.__name__}')
+			await cog0.on_setting_updated(interaction.guild, setting)
+			cog0.log(interaction.guild, f'{interaction.user.name} enabled {cog0.__class__.__name__}')
 		setattr(cog.__class__, f'_cmd_enable', enabler)
 		enabler.__qualname__ = f'{cog.__class__.__name__}._cmd_enable'
 		enabler.__self__ = cog
 
 		command = Command(
 			name=cog.config_prefix,
-			description=f'Enables {cog.name} functionality',
+			description=f'Enables {cog.qualified_name} functionality.',
 			callback=enabler,
 			parent=CogSetting.__enable_group,
+			extras={
+				'cog': cog,
+				'setting': setting,
+				'long_description': setting.description,
+			},
 		)
-		# command.cog = cog
-		# _fix_command(command)
 		return command
 
 	def __make_disable_command(self, cog: BaseCog) -> Command:
 		setting: CogSetting = self
-		async def disabler(self: BaseCog, interaction: Interaction) -> None:
-			print(f"invoking disable for {self.config_prefix}")
-			key = f'{self.__class__.__name__}.{setting.name}'
+		async def disabler(cog0: BaseCog, interaction: Interaction) -> None:
+			print(f"invoking disable for {cog0.config_prefix}")
+			key = f'{cog0.__class__.__name__}.{setting.name}'
 			Storage.set_config_value(interaction.guild, key, False)
 			await interaction.response.send_message(
 				f'{CONFIG["success_emoji"]} {setting.brief.capitalize()} disabled.',
 				ephemeral=True
 			)
-			await self.on_setting_updated(interaction.guild, setting)
-			self.log(interaction.guild, f'{interaction.user.name} disabled {self.__class__.__name__}')
+			await cog0.on_setting_updated(interaction.guild, setting)
+			cog0.log(interaction.guild, f'{interaction.user.name} disabled {cog0.__class__.__name__}')
 		setattr(cog.__class__, f'_cmd_disable', disabler)
 		disabler.__qualname__ = f'{cog.__class__.__name__}._cmd_disable'
 		disabler.__self__ = cog
 			description=f'Disables {cog.config_prefix} functionality',
 			callback=disabler,
 			parent=CogSetting.__disable_group,
+			extras={
+				'cog': cog,
+				'setting': setting,
+				'long_description': setting.description,
+			},
 		)
-		# command.cog = cog
-		# _fix_command(command)
 		return command
 
 	__has_set_up_base_commands: bool = False
 		cls.__has_set_up_base_commands = True
 		cls.__set_group = Group(
 			name='set',
-			description='Sets a bot configuration value for this guild',
-			default_permissions=cls.permissions
+			description='Sets a configuration value for this guild.',
+			default_permissions=MOD_PERMISSIONS,
+			extras={
+				'long_description': 'Settings are guild-specific. If no value is set, a default is used. Use `/get` to '
+									'see the current value for this guild.',
+			},
 		)
 		cls.__get_group = Group(
 			name='get',
-			description='Shows a configured bot value for this guild',
-			default_permissions=cls.permissions
+			description='Shows a configuration value for this guild.',
+			default_permissions=MOD_PERMISSIONS,
+			extras={
+				'long_description': 'Settings are guild-specific. Shows the configured value or default value for a '
+									'variable for this guild. Use `/set` to change the value.',
+			},
 		)
 		cls.__enable_group = Group(
 			name='enable',
-			description='Enables bot functionality for this guild',
-			default_permissions=cls.permissions
+			description='Enables a module for this guild',
+			default_permissions=MOD_PERMISSIONS,
+			extras={
+				'long_description': 'Modules are enabled on a per-guild basis and are off by default. Use `/disable` '
+									'to disable an enabled module.',
+			},
 		)
 		cls.__disable_group = Group(
 			name='disable',
-			description='Disables bot functionality for this guild',
-			default_permissions=cls.permissions
+			description='Disables a module for this guild.',
+			default_permissions=MOD_PERMISSIONS,
+			extras={
+				'long_description': 'Modules are enabled on a per-guild basis and are off by default. Use `/enable` '
+					                're-enable a disabled module.',
+			},
 		)
 		bot.tree.add_command(cls.__set_group)
 		bot.tree.add_command(cls.__get_group)