More help command work

config.sample.py

 	'info_emoji': 'ℹ️',
 	# Logging something that happened on the server (e.g. a user joined the server)
 	'log_emoji': '📋',
+	# A task is in progress
+	'wait_emoji': '⏳',
 
     # -----------------------------------------------------------------------
     # Default values for cog-specific settings that a guild has not overridden

rocketbot/cogs/autokickcog.py

 		brief='autokick',
 		description='Whether this cog is enabled for a guild.')
 	SETTING_BAN_COUNT = CogSetting('bancount', int,
-			brief='number of repeat kicks before a ban',
-			description='The number of times a user can join and be kicked ' + \
-					'before the next rejoin will result in a ban. A value of 0 ' + \
+		brief='number of repeat kicks before a ban',
+		description='The number of times a user can join and be kicked '
+					'before the next rejoin will result in a ban. A value of 0 '
 					'disables this feature (only kick, never ban).',
-			usage='<count:int>',
-			min_value=0)
+		usage='<count:int>',
+		min_value=0)
 	SETTING_OFFLINE_ONLY = CogSetting('offlineonly', bool,
-			brief='whether to only kick users whose status is offline',
-			description='Compromised accounts may have a status of offline. ' + \
-					'If this setting is enabled, the user\'s status will be ' + \
-					'checked a few seconds after joining. If it is offline ' + \
+		brief='whether to only kick users whose status is offline',
+		description='Compromised accounts may have a status of offline. '
+					'If this setting is enabled, the user\'s status will be '
+					'checked a few seconds after joining. If it is offline '
 					'they will be kicked.',
-			usage='<true|false>')
+		usage='<true|false>')
 
 	STATE_KEY_RECENT_KICKS = "AutoKickCog.recent_joins"
 
 		else:
 			await member.kick(reason='Rocketbot: Autokick enabled.')
 			msg = BotMessage(guild,
-							text=f'Autokicked {member.mention} ({member.id}) ' + \
-								f'({AutoKickCog.ordinal(context.kick_count)} time). ' + \
-								disable_help + ' ' + ban_help,
-							type=BotMessage.TYPE_INFO,
-							context=None)
+				text=f'Autokicked {member.mention} ({member.id}) ' + \
+					f'({AutoKickCog.ordinal(context.kick_count)} time). ' + \
+					disable_help + ' ' + ban_help,
+				type=BotMessage.TYPE_INFO,
+				context=None)
 			await self.post_message(msg)
 			self.log(guild, f'Autokicked {member.name} ' + \
 				f'({AutoKickCog.ordinal(context.kick_count)} time)')

rocketbot/cogs/basecog.py

 
 	@classmethod
 	def get_guild_setting(cls,
-			guild: Guild,
+			guild: Optional[Guild],
 			setting: CogSetting,
 			use_cog_default_if_not_set: bool = True):
 		"""
 		unless the optional `use_cog_default_if_not_set` is `False`, then
 		`None` will be returned.
 		"""
-		key = f'{cls.__name__}.{setting.name}'
-		value = Storage.get_config_value(guild, key)
-		if value is None and use_cog_default_if_not_set:
-			value = cls.get_cog_default(setting.name)
-		return value
+		if guild:
+			key = f'{cls.__name__}.{setting.name}'
+			value = Storage.get_config_value(guild, key)
+			if value is not None:
+				return value
+		if use_cog_default_if_not_set:
+			return cls.get_cog_default(setting.name)
+		return None
 
 	@classmethod
 	def set_guild_setting(cls,

rocketbot/cogs/generalcog.py

 			self.log(None, f'Session resumed after {disconnect_duration.total_seconds()} seconds')
 
 	@command(
-		description='Posts a test warning',
+		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.',
+			'long_description': 'Simulates a warning. The configured warning channel '
+								'and mod mention will be used.',
 		},
 	)
 	@guild_only()
 	@default_permissions(ban_members=True)
 	async def test_warn(self, interaction: Interaction):
-		"""Command handler"""
 		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!',
 			)
 
 	@command(
-		description='Greets the user',
+		description='Greets the user.',
 		extras={
-			'long_description': 'Replies to the command message. Useful to ensure the ' + \
-				'bot is working properly.',
+			'long_description': 'Replies to the command message. Useful to ensure the '
+								'bot is responsive. Message is only visible to the user.',
 		},
 	)
 	async def hello(self, interaction: Interaction):
 		)
 
 	@command(
-		description='Shuts down the bot',
+		description='Shuts down the bot.',
 		extras={
-			'long_description': 'Causes the bot script to terminate. Only usable by a ' + \
-				'user with server admin permissions.',
+			'long_description': 'Terminates the bot script. Only usable by a '
+								'server administrator.',
 		},
 	)
 	@guild_only()
 		await self.bot.close()
 
 	@command(
-		description='Mass deletes messages',
+		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 ' +
 	@guild_only()
 	@default_permissions(manage_messages=True)
 	async def delete_messages(self, interaction: Interaction, user: User, age: Transform[timedelta, TimeDeltaTransformer]) -> None:
-		"""Command handler"""
+		"""
+		Mass deletes messages.
+
+		Parameters
+		----------
+		interaction: :class:`Interaction`
+		user: :class:`User`
+			user to delete messages from
+		age: :class:`timedelta`
+			maximum age of messages to delete
+		"""
 		member_id = user.id
 		cutoff: datetime = datetime.now(timezone.utc) - age
+
+		resp = await interaction.response.defer(ephemeral=True, thinking=True)
+
 		def predicate(message: Message) -> bool:
 			return str(message.author.id) == member_id and message.created_at >= cutoff
 		deleted_messages = []
 			except DiscordException:
 				# XXX: Sloppily glossing over access errors instead of checking access
 				pass
-		await interaction.response.send_message(
-			f'{CONFIG["success_emoji"]} Deleted {len(deleted_messages)} ' + \
-			f'messages by {user.mention}> from the past {describe_timedelta(age)}.',
-			ephemeral=True,
-		)
+
+		if len(deleted_messages) > 0:
+			await resp.resource.edit(
+				content=f'{CONFIG["success_emoji"]} Deleted {len(deleted_messages)} '
+						f'messages by {user.mention} from the past {describe_timedelta(age)}.',
+			)
+		else:
+			await resp.resource.edit(
+				content=f'{CONFIG["success_emoji"]} No messages found for {user.mention} '
+						'from the past {describe_timedelta(age)}.',
+			)

rocketbot/cogs/helpcog.py

 			print(f'Subcommands for {cmd_name} was None')
 			return []
 		return [
-			Choice(name=f'{subcmd_name} subcommand', value=f'subcmd:{cmd_name}.{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 current in subcmd_name
 		][:25]
 			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()
 		----------
 		interaction: Interaction
 		topic: Optional[str]
-			Optional topic to get specific help for. Getting help on a command can optionally start with a leading slash.
+			optional command, module, or keywords to get specific help for
 		subtopic: Optional[str]
-			Optional subtopic to get specific help for.
+			optional subcommand to get specific help for
 		"""
 		print(f'help_command(interaction, {topic}, {subtopic})')
 
 		)
 
 	async def __send_command_help(self, interaction: Interaction, command_or_group: Union[Command, Group], addendum: Optional[str] = None) -> None:
+		if isinstance(command_or_group, Command):
+			print(f"Doc:\n{command_or_group.callback.__doc__}")
 		text = ''
 		if addendum is not None:
 			text += addendum + '\n\n'
 		if isinstance(command_or_group, Group):
 			subcmds: dict[str, Command] = self.get_subcommand_list(command_or_group, permissions=interaction.permissions)
 			if len(subcmds) > 0:
-				text += '\n\n### Subcommands:'
+				text += '\n### Subcommands:'
 				for subcmd_name, subcmd in sorted(subcmds.items()):
 					text += f'\n- `{subcmd_name}`: {subcmd.description}'
 		else:
 			params = command_or_group.parameters
 			if len(params) > 0:
-				text += '\n\n### Parameters:'
+				text += '\n### Parameters:'
 				for param in params:
 					text += f'\n- `{param.name}`: {param.description}'
 		await interaction.response.send_message(text, ephemeral=True)
 
 	async def __send_subcommand_help(self, interaction: Interaction, group: Group, subcommand: Command) -> None:
-		text = f'## :information_source: Subcommand Help\n`/{group.name} {subcommand.name}`\n\n{subcommand.description}\n\n{subcommand.description}'
+		text = f'## :information_source: Subcommand Help'
+		text += f'\n`/{group.name} {subcommand.name}`'
+		text += f'\n\n{subcommand.description}'
 		params = subcommand.parameters
 		if len(params) > 0:
-			text += '\n\n### Parameters:'
+			text += '\n### Parameters:'
 			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}'
+		text = f'## :information_source: Module Help'
+		text += f'\n**{cog.qualified_name}** module'
 		if cog.description is not None:
-			text += f'\n{cog.description}'
+			text += f'\n\n{cog.description}'
+
+		cmds = [
+			cmd
+			for cmd in sorted(cog.get_app_commands(), key=lambda c: c.name)
+			if can_use_command(cmd, interaction.permissions)
+		]
+		if len(cmds) > 0:
+			text += '\n### Commands:'
+			for cmd in cmds:
+				text += f'\n- `/{cmd.name}` - {cmd.description}'
+				if isinstance(cmd, Group):
+					subcmds = [ subcmd for subcmd in cmd.commands if can_use_command(subcmd, interaction.permissions) ]
+					if len(subcmds) > 0:
+						text += f' ({len(subcmds)} subcommands)'
+
 		settings = cog.settings
 		if len(settings) > 0:
 			text += '\n### Configuration'
 			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}'
+				text += f'\n- `/get` or `/set {cog.config_prefix}_{setting.name}` - {setting.brief}'
+		print(text)
 		await interaction.response.send_message(
 			text,
 			ephemeral=True,

rocketbot/cogs/urlspamcog.py

 			enum_values={'nothing', 'modwarn', 'delete', 'kick', 'ban'})
 	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 ' + \
-				'who joined too recently will be flagged. Keep in mind ' + \
-				'many servers have a minimum 10 minute cooldown before ' + \
-				'new members can say anything. Setting to 0 effectively ' + \
+			description='The minimum seconds since the user joined the '
+				'server before they can post URLs. URLs posted by users '
+				'who joined too recently will be flagged. Keep in mind '
+				'many servers have a minimum 10 minute cooldown before '
+				'new members can say anything. Setting to 0 effectively '
 				'disables URL spam detection.',
 			usage='<seconds:int>',
 			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 ' + \
+			description='The action to take on chat messages with links '
 				'where the text looks like a different URL than the actual link.',
 			enum_values={'nothing', 'modwarn', 'modwarndelete',
 				'chatwarn', 'chatwarndelete', 'delete', 'kick', 'ban'})

rocketbot/cogs/usernamecog.py

 	)
 
 	@username.command(
-		description='Adds a username pattern',
+		description='Adds a username pattern to match against new members.',
 		extras={
 			'long_description': 'Adds a username pattern.',
 			'usage': '<pattern>',
 		},
 	)
 	async def add(self, interaction: Interaction, pattern: str) -> None:
-		"""Command handler"""
+		"""
+		Adds a username pattern to match against new members.
+
+		Parameters
+		----------
+		interaction : Interaction
+		pattern : str
+			a substring to look for in usernames
+		"""
 		norm_pattern = pattern.lower()
 		patterns: list[str] = self.__get_patterns(interaction.guild)
 		if norm_pattern in patterns:
 			await interaction.response.send_message(
-				f'Pattern `{norm_pattern}` already added.',
+				f'{CONFIG["warning_emoji"]} Pattern `{norm_pattern}` already added.',
 				ephemeral=True
 			)
 			return
 		patterns.append(norm_pattern)
 		self.__save_patterns(interaction.guild, patterns)
 		await interaction.response.send_message(
-			f'Pattern `{norm_pattern}` added.',
+			f'{CONFIG["success_emoji"]} Pattern `{norm_pattern}` added.',
 			ephemeral=True
 		)
 
 	@username.command(
-		description='Removes a username pattern',
+		description='Removes a username pattern.',
 		extras={
 			'long_description': 'Removes an existing username pattern',
 			'usage': '<pattern>',
 		},
 	)
 	async def remove(self, interaction: Interaction, pattern: str) -> None:
-		"""Command handler"""
+		"""
+		Removes a username pattern.
+
+		Parameters
+		----------
+		interaction : Interaction
+		pattern : str
+		    the existing username pattern to remove
+		"""
 		norm_pattern = pattern.lower()
 		guild: Guild = interaction.guild
 		patterns: list[str] = self.__get_patterns(guild)
 		patterns = list(filter(lambda p: p != norm_pattern, patterns))
 		if len(patterns) == len_before:
 			await interaction.response.send_message(
-				f'Pattern `{norm_pattern}` not found.',
+				f'{CONFIG["warning_emoji"]} Pattern `{norm_pattern}` not found.',
 				ephemeral=True,
 			)
 			return
 		self.__save_patterns(guild, patterns)
 		await interaction.response.send_message(
-			f'Pattern `{norm_pattern}` removed.',
+			f'{CONFIG["success_emoji"]} Pattern `{norm_pattern}` removed.',
 			ephemeral=True,
 		)
 
 	@username.command(
-		description='Lists username patterns'
+		description='Lists existing username patterns.'
 	)
 	async def list(self, interaction: Interaction) -> None:
 		"""Command handler"""
 		patterns: list[str] = self.__get_patterns(guild)
 		if len(patterns) == 0:
 			await interaction.response.send_message(
-				'No patterns defined',
+				f'{CONFIG["success_emoji"]} No patterns defined.',
 				ephemeral=True,
 			)
 		else:
-			msg = 'Patterns:\n\n> `' + '`\n> `'.join(patterns) + '`'
+			msg = f'{CONFIG["info_emoji"]} Patterns:\n\n> `' + '`\n> `'.join(patterns) + '`'
 			await interaction.response.send_message(
 				msg,
 				ephemeral=True,