fix: Properly implement slash commands - Use app_commands for slash command support - Add proper command group structure - Handle command registration and syncing

videoarchiver/__init__.py

@@ -1,13 +1,12 @@
 """VideoArchiver cog for Red-DiscordBot"""
-
 from redbot.core.bot import Red
-from redbot.core.utils import get_end_user_data_statement
+from .video_archiver import VideoArchiver
 
-from videoarchiver.video_archiver import VideoArchiver
-from videoarchiver.ffmpeg.ffmpeg_manager import FFmpegManager
-from videoarchiver.ffmpeg.exceptions import FFmpegError, GPUError, DownloadError
-
-__red_end_user_data_statement__ = get_end_user_data_statement(__file__)
-
-async def setup(bot: Red):
-    await bot.add_cog(VideoArchiver(bot))
+async def setup(bot: Red) -> None:
+    """Load VideoArchiver."""
+    cog = VideoArchiver(bot)
+    await bot.add_cog(cog)
+    # Sync commands with Discord
+    if not hasattr(bot, "tree"):
+        return
+    await bot.tree.sync()

videoarchiver/commands.py

@@ -1,7 +1,7 @@
 """Discord commands for VideoArchiver"""
 import discord
-from redbot.core import commands, checks
-from typing import Optional
+from redbot.core import commands, app_commands
+from typing import Optional, Literal
 import yt_dlp
 from datetime import datetime
 
@@ -15,185 +15,188 @@ class VideoArchiverCommands(commands.Cog):
         self.processor = processor
         super().__init__()
 
-    @commands.hybrid_group(name="videoarchiver", aliases=["va"], fallback="settings")
-    @commands.guild_only()
+    videoarchiver = app_commands.Group(
+        name="videoarchiver",
+        description="Video Archiver configuration commands",
+        guild_only=True
+    )
+
+    @videoarchiver.command(name="settings")
+    @app_commands.guild_only()
     @commands.admin_or_permissions(administrator=True)
-    async def videoarchiver(self, ctx: commands.Context):
-        """Video Archiver configuration commands"""
-        if ctx.invoked_subcommand is None:
-            embed = await self.config.format_settings_embed(ctx.guild)
-            await ctx.send(embed=embed)
+    async def settings(self, interaction: discord.Interaction):
+        """Show current settings"""
+        embed = await self.config.format_settings_embed(interaction.guild)
+        await interaction.response.send_message(embed=embed)
 
     @videoarchiver.command(name="updateytdlp")
-    @commands.guild_only()
-    @checks.is_owner()
-    async def update_ytdlp(self, ctx: commands.Context):
+    @app_commands.guild_only()
+    @commands.is_owner()
+    async def update_ytdlp(self, interaction: discord.Interaction):
         """Update yt-dlp to the latest version"""
         success, message = await self.update_checker.update_yt_dlp()
-        await ctx.send("✅ " + message if success else "❌ " + message)
+        await interaction.response.send_message("✅ " + message if success else "❌ " + message)
 
     @videoarchiver.command(name="toggleupdates")
-    @commands.guild_only()
+    @app_commands.guild_only()
     @commands.admin_or_permissions(administrator=True)
-    async def toggle_update_check(self, ctx: commands.Context):
+    async def toggle_update_check(self, interaction: discord.Interaction):
         """Toggle yt-dlp update notifications"""
-        state = await self.config.toggle_setting(ctx.guild.id, "disable_update_check")
+        state = await self.config.toggle_setting(interaction.guild.id, "disable_update_check")
         status = "disabled" if state else "enabled"
-        await ctx.send(f"Update notifications {status}")
+        await interaction.response.send_message(f"Update notifications {status}")
 
     @videoarchiver.command(name="addrole")
-    @commands.guild_only()
-    async def add_allowed_role(self, ctx: commands.Context, role: Optional[discord.Role] = None):
-        """Add a role that's allowed to trigger archiving (leave empty for @everyone)"""
-        role_id = role.id if role else ctx.guild.default_role.id
-        role_name = role.name if role else "@everyone"
-        
-        # If no role is specified, clear the list to allow everyone
+    @app_commands.guild_only()
+    @app_commands.describe(role="The role to allow (leave empty for @everyone)")
+    async def add_allowed_role(self, interaction: discord.Interaction, role: Optional[discord.Role] = None):
+        """Add a role that's allowed to trigger archiving"""
         if not role:
-            await self.config.update_setting(ctx.guild.id, "allowed_roles", [])
-            await ctx.send("Allowed role set to @everyone (all users can trigger archiving)")
+            # If no role is specified, clear the list to allow everyone
+            await self.config.update_setting(interaction.guild.id, "allowed_roles", [])
+            await interaction.response.send_message("Allowed role set to @everyone (all users can trigger archiving)")
             return
             
-        await self.config.add_to_list(ctx.guild.id, "allowed_roles", role_id)
-        await ctx.send(f"Added {role_name} to allowed roles")
+        await self.config.add_to_list(interaction.guild.id, "allowed_roles", role.id)
+        await interaction.response.send_message(f"Added {role.name} to allowed roles")
 
     @videoarchiver.command(name="removerole")
-    @commands.guild_only()
-    async def remove_allowed_role(self, ctx: commands.Context, role: discord.Role):
+    @app_commands.guild_only()
+    @app_commands.describe(role="The role to remove")
+    async def remove_allowed_role(self, interaction: discord.Interaction, role: discord.Role):
         """Remove a role from allowed roles"""
-        await self.config.remove_from_list(ctx.guild.id, "allowed_roles", role.id)
-        await ctx.send(f"Removed {role.name} from allowed roles")
+        await self.config.remove_from_list(interaction.guild.id, "allowed_roles", role.id)
+        await interaction.response.send_message(f"Removed {role.name} from allowed roles")
 
     @videoarchiver.command(name="listroles")
-    @commands.guild_only()
-    async def list_allowed_roles(self, ctx: commands.Context):
+    @app_commands.guild_only()
+    async def list_allowed_roles(self, interaction: discord.Interaction):
         """List all roles allowed to trigger archiving"""
-        roles = await self.config.get_setting(ctx.guild.id, "allowed_roles")
+        roles = await self.config.get_setting(interaction.guild.id, "allowed_roles")
         if not roles:
-            await ctx.send(
+            await interaction.response.send_message(
                 "No roles are currently set (all users can trigger archiving)"
             )
             return
         role_names = [
             r.name if r else "@everyone" 
-            for r in [ctx.guild.get_role(role_id) for role_id in roles]
+            for r in [interaction.guild.get_role(role_id) for role_id in roles]
         ]
-        await ctx.send(f"Allowed roles: {', '.join(role_names)}")
+        await interaction.response.send_message(f"Allowed roles: {', '.join(role_names)}")
 
     @videoarchiver.command(name="setconcurrent")
-    @commands.guild_only()
-    async def set_concurrent_downloads(self, ctx: commands.Context, count: int):
-        """Set the number of concurrent downloads (1-5)"""
-        if not 1 <= count <= 5:
-            await ctx.send("Concurrent downloads must be between 1 and 5")
-            return
-        await self.config.update_setting(ctx.guild.id, "concurrent_downloads", count)
-        await ctx.send(f"Concurrent downloads set to {count}")
+    @app_commands.guild_only()
+    @app_commands.describe(count="Number of concurrent downloads (1-5)")
+    async def set_concurrent_downloads(self, interaction: discord.Interaction, count: app_commands.Range[int, 1, 5]):
+        """Set the number of concurrent downloads"""
+        await self.config.update_setting(interaction.guild.id, "concurrent_downloads", count)
+        await interaction.response.send_message(f"Concurrent downloads set to {count}")
 
     @videoarchiver.command(name="setchannel")
-    @commands.guild_only()
-    async def set_archive_channel(
-        self, ctx: commands.Context, channel: discord.TextChannel
-    ):
+    @app_commands.guild_only()
+    @app_commands.describe(channel="The archive channel")
+    async def set_archive_channel(self, interaction: discord.Interaction, channel: discord.TextChannel):
         """Set the archive channel"""
-        await self.config.update_setting(ctx.guild.id, "archive_channel", channel.id)
-        await ctx.send(f"Archive channel set to {channel.mention}")
+        await self.config.update_setting(interaction.guild.id, "archive_channel", channel.id)
+        await interaction.response.send_message(f"Archive channel set to {channel.mention}")
 
     @videoarchiver.command(name="setnotification")
-    @commands.guild_only()
-    async def set_notification_channel(
-        self, ctx: commands.Context, channel: discord.TextChannel
-    ):
+    @app_commands.guild_only()
+    @app_commands.describe(channel="The notification channel")
+    async def set_notification_channel(self, interaction: discord.Interaction, channel: discord.TextChannel):
         """Set the notification channel (where archive messages appear)"""
         await self.config.update_setting(
-            ctx.guild.id, "notification_channel", channel.id
+            interaction.guild.id, "notification_channel", channel.id
         )
-        await ctx.send(f"Notification channel set to {channel.mention}")
+        await interaction.response.send_message(f"Notification channel set to {channel.mention}")
 
     @videoarchiver.command(name="setlogchannel")
-    @commands.guild_only()
-    async def set_log_channel(
-        self, ctx: commands.Context, channel: discord.TextChannel
-    ):
+    @app_commands.guild_only()
+    @app_commands.describe(channel="The log channel")
+    async def set_log_channel(self, interaction: discord.Interaction, channel: discord.TextChannel):
         """Set the log channel for error messages and notifications"""
-        await self.config.update_setting(ctx.guild.id, "log_channel", channel.id)
-        await ctx.send(f"Log channel set to {channel.mention}")
+        await self.config.update_setting(interaction.guild.id, "log_channel", channel.id)
+        await interaction.response.send_message(f"Log channel set to {channel.mention}")
 
     @videoarchiver.command(name="addmonitor")
-    @commands.guild_only()
-    async def add_monitored_channel(
-        self, ctx: commands.Context, channel: Optional[discord.TextChannel] = None
-    ):
-        """Add a channel to monitor for videos (leave empty to monitor all channels)"""
+    @app_commands.guild_only()
+    @app_commands.describe(channel="The channel to monitor (leave empty to monitor all channels)")
+    async def add_monitored_channel(self, interaction: discord.Interaction, channel: Optional[discord.TextChannel] = None):
+        """Add a channel to monitor for videos"""
         if not channel:
             # If no channel is specified, clear the list to monitor all channels
-            await self.config.update_setting(ctx.guild.id, "monitored_channels", [])
-            await ctx.send("Now monitoring all channels for videos")
+            await self.config.update_setting(interaction.guild.id, "monitored_channels", [])
+            await interaction.response.send_message("Now monitoring all channels for videos")
             return
             
-        await self.config.add_to_list(ctx.guild.id, "monitored_channels", channel.id)
-        await ctx.send(f"Now monitoring {channel.mention} for videos")
+        await self.config.add_to_list(interaction.guild.id, "monitored_channels", channel.id)
+        await interaction.response.send_message(f"Now monitoring {channel.mention} for videos")
 
     @videoarchiver.command(name="removemonitor")
-    @commands.guild_only()
-    async def remove_monitored_channel(
-        self, ctx: commands.Context, channel: discord.TextChannel
-    ):
+    @app_commands.guild_only()
+    @app_commands.describe(channel="The channel to stop monitoring")
+    async def remove_monitored_channel(self, interaction: discord.Interaction, channel: discord.TextChannel):
         """Remove a channel from monitoring"""
         await self.config.remove_from_list(
-            ctx.guild.id, "monitored_channels", channel.id
+            interaction.guild.id, "monitored_channels", channel.id
         )
-        await ctx.send(f"Stopped monitoring {channel.mention}")
+        await interaction.response.send_message(f"Stopped monitoring {channel.mention}")
 
     @videoarchiver.command(name="setformat")
-    @commands.guild_only()
-    async def set_video_format(self, ctx: commands.Context, format: str):
-        """Set the video format (e.g., mp4, webm)"""
-        await self.config.update_setting(ctx.guild.id, "video_format", format.lower())
-        await ctx.send(f"Video format set to {format.lower()}")
+    @app_commands.guild_only()
+    @app_commands.describe(format="The video format (e.g., mp4, webm)")
+    async def set_video_format(self, interaction: discord.Interaction, format: Literal["mp4", "webm"]):
+        """Set the video format"""
+        await self.config.update_setting(interaction.guild.id, "video_format", format.lower())
+        await interaction.response.send_message(f"Video format set to {format.lower()}")
 
     @videoarchiver.command(name="setquality")
-    @commands.guild_only()
-    async def set_video_quality(self, ctx: commands.Context, quality: int):
-        """Set the maximum video quality in pixels (e.g., 1080)"""
-        await self.config.update_setting(ctx.guild.id, "video_quality", quality)
-        await ctx.send(f"Maximum video quality set to {quality}p")
+    @app_commands.guild_only()
+    @app_commands.describe(quality="Maximum video quality in pixels (e.g., 1080)")
+    async def set_video_quality(self, interaction: discord.Interaction, quality: app_commands.Range[int, 144, 4320]):
+        """Set the maximum video quality"""
+        await self.config.update_setting(interaction.guild.id, "video_quality", quality)
+        await interaction.response.send_message(f"Maximum video quality set to {quality}p")
 
     @videoarchiver.command(name="setmaxsize")
-    @commands.guild_only()
-    async def set_max_file_size(self, ctx: commands.Context, size: int):
-        """Set the maximum file size in MB"""
-        await self.config.update_setting(ctx.guild.id, "max_file_size", size)
-        await ctx.send(f"Maximum file size set to {size}MB")
+    @app_commands.guild_only()
+    @app_commands.describe(size="Maximum file size in MB")
+    async def set_max_file_size(self, interaction: discord.Interaction, size: app_commands.Range[int, 1, 100]):
+        """Set the maximum file size"""
+        await self.config.update_setting(interaction.guild.id, "max_file_size", size)
+        await interaction.response.send_message(f"Maximum file size set to {size}MB")
 
     @videoarchiver.command(name="toggledelete")
-    @commands.guild_only()
-    async def toggle_delete_after_repost(self, ctx: commands.Context):
+    @app_commands.guild_only()
+    async def toggle_delete_after_repost(self, interaction: discord.Interaction):
         """Toggle whether to delete local files after reposting"""
-        state = await self.config.toggle_setting(ctx.guild.id, "delete_after_repost")
-        await ctx.send(f"Delete after repost: {state}")
+        state = await self.config.toggle_setting(interaction.guild.id, "delete_after_repost")
+        await interaction.response.send_message(f"Delete after repost: {state}")
 
     @videoarchiver.command(name="setduration")
-    @commands.guild_only()
-    async def set_message_duration(self, ctx: commands.Context, hours: int):
-        """Set how long to keep archive messages (0 for permanent)"""
-        await self.config.update_setting(ctx.guild.id, "message_duration", hours)
-        await ctx.send(f"Archive message duration set to {hours} hours")
+    @app_commands.guild_only()
+    @app_commands.describe(hours="Duration in hours (0 for permanent)")
+    async def set_message_duration(self, interaction: discord.Interaction, hours: app_commands.Range[int, 0, 720]):
+        """Set how long to keep archive messages"""
+        await self.config.update_setting(interaction.guild.id, "message_duration", hours)
+        await interaction.response.send_message(f"Archive message duration set to {hours} hours")
 
     @videoarchiver.command(name="settemplate")
-    @commands.guild_only()
-    async def set_message_template(self, ctx: commands.Context, *, template: str):
-        """Set the archive message template. Use {author}, {url}, and {original_message} as placeholders"""
-        await self.config.update_setting(ctx.guild.id, "message_template", template)
-        await ctx.send(f"Archive message template set to:\n{template}")
+    @app_commands.guild_only()
+    @app_commands.describe(template="Message template using {author}, {url}, and {original_message}")
+    async def set_message_template(self, interaction: discord.Interaction, template: str):
+        """Set the archive message template"""
+        await self.config.update_setting(interaction.guild.id, "message_template", template)
+        await interaction.response.send_message(f"Archive message template set to:\n{template}")
 
     @videoarchiver.command(name="enablesites")
-    @commands.guild_only()
-    async def enable_sites(self, ctx: commands.Context, *, sites: Optional[str] = None):
-        """Enable specific sites (leave empty for all sites). Separate multiple sites with spaces."""
+    @app_commands.guild_only()
+    @app_commands.describe(sites="Sites to enable (leave empty for all sites)")
+    async def enable_sites(self, interaction: discord.Interaction, sites: Optional[str] = None):
+        """Enable specific sites"""
         if sites is None:
-            await self.config.update_setting(ctx.guild.id, "enabled_sites", [])
-            await ctx.send("All sites enabled")
+            await self.config.update_setting(interaction.guild.id, "enabled_sites", [])
+            await interaction.response.send_message("All sites enabled")
             return
 
         site_list = [s.strip().lower() for s in sites.split()]
@@ -203,19 +206,19 @@ class VideoArchiverCommands(commands.Cog):
             valid_sites = set(ie.IE_NAME.lower() for ie in ydl._ies)
             invalid_sites = [s for s in site_list if s not in valid_sites]
             if invalid_sites:
-                await ctx.send(
+                await interaction.response.send_message(
                     f"Invalid sites: {', '.join(invalid_sites)}\nValid sites: {', '.join(valid_sites)}"
                 )
                 return
 
-        await self.config.update_setting(ctx.guild.id, "enabled_sites", site_list)
-        await ctx.send(f"Enabled sites: {', '.join(site_list)}")
+        await self.config.update_setting(interaction.guild.id, "enabled_sites", site_list)
+        await interaction.response.send_message(f"Enabled sites: {', '.join(site_list)}")
 
     @videoarchiver.command(name="listsites")
-    @commands.guild_only()
-    async def list_sites(self, ctx: commands.Context):
+    @app_commands.guild_only()
+    async def list_sites(self, interaction: discord.Interaction):
         """List all available sites and currently enabled sites"""
-        enabled_sites = await self.config.get_setting(ctx.guild.id, "enabled_sites")
+        enabled_sites = await self.config.get_setting(interaction.guild.id, "enabled_sites")
 
         embed = discord.Embed(
             title="Video Sites Configuration", color=discord.Color.blue()
@@ -243,14 +246,14 @@ class VideoArchiverCommands(commands.Cog):
             inline=False,
         )
 
-        await ctx.send(embed=embed)
+        await interaction.response.send_message(embed=embed)
 
     @videoarchiver.command(name="queue")
-    @commands.guild_only()
+    @app_commands.guild_only()
     @commands.admin_or_permissions(administrator=True)
-    async def show_queue(self, ctx: commands.Context):
+    async def show_queue(self, interaction: discord.Interaction):
         """Show current queue status with basic metrics"""
-        status = self.processor.queue_manager.get_queue_status(ctx.guild.id)
+        status = self.processor.queue_manager.get_queue_status(interaction.guild.id)
 
         embed = discord.Embed(
             title="Video Processing Queue Status",
@@ -281,15 +284,15 @@ class VideoArchiverCommands(commands.Cog):
             inline=False
         )
 
-        embed.set_footer(text="Use [p]va queuemetrics for detailed performance metrics")
-        await ctx.send(embed=embed)
+        embed.set_footer(text="Use /videoarchiver queuemetrics for detailed performance metrics")
+        await interaction.response.send_message(embed=embed)
 
     @videoarchiver.command(name="queuemetrics")
-    @commands.guild_only()
+    @app_commands.guild_only()
     @commands.admin_or_permissions(administrator=True)
-    async def show_queue_metrics(self, ctx: commands.Context):
+    async def show_queue_metrics(self, interaction: discord.Interaction):
         """Show detailed queue performance metrics"""
-        status = self.processor.queue_manager.get_queue_status(ctx.guild.id)
+        status = self.processor.queue_manager.get_queue_status(interaction.guild.id)
         metrics = status['metrics']
 
         embed = discord.Embed(
@@ -333,12 +336,12 @@ class VideoArchiverCommands(commands.Cog):
         )
 
         embed.set_footer(text="Metrics are updated in real-time as videos are processed")
-        await ctx.send(embed=embed)
+        await interaction.response.send_message(embed=embed)
 
     @videoarchiver.command(name="clearqueue")
-    @commands.guild_only()
+    @app_commands.guild_only()
     @commands.admin_or_permissions(administrator=True)
-    async def clear_queue(self, ctx: commands.Context):
+    async def clear_queue(self, interaction: discord.Interaction):
         """Clear the video processing queue for this guild"""
-        cleared = await self.processor.queue_manager.clear_guild_queue(ctx.guild.id)
-        await ctx.send(f"Cleared {cleared} items from the queue")
+        cleared = await self.processor.queue_manager.clear_guild_queue(interaction.guild.id)
+        await interaction.response.send_message(f"Cleared {cleared} items from the queue")

videoarchiver/video_archiver.py

@@ -2,7 +2,7 @@
 from __future__ import annotations
 
 import discord
-from redbot.core import commands, Config, data_manager
+from redbot.core import commands, Config, data_manager, app_commands
 from pathlib import Path
 import logging
 import asyncio
@@ -29,13 +29,7 @@ from videoarchiver.exceptions import (
 
 logger = logging.getLogger('VideoArchiver')
 
-def setup(bot):
-    """Load the VideoArchiver cog."""
-    cog = VideoArchiver(bot)
-    asyncio.create_task(bot.add_cog(cog))
-    return cog
-
-class VideoArchiver(VideoArchiverCommands):
+class VideoArchiver(commands.Cog):
     """Archive videos from Discord channels"""
 
     def __init__(self, bot: commands.Bot) -> None:
@@ -82,8 +76,13 @@ class VideoArchiver(VideoArchiverCommands):
             self.update_checker = UpdateChecker(self.bot, self.config_manager)
             self.processor = VideoProcessor(self.bot, self.config_manager, self.components)
             
-            # Initialize base class last
-            super().__init__(self.bot, self.config_manager, self.update_checker, self.processor)
+            # Initialize commands handler
+            self.commands_handler = VideoArchiverCommands(
+                self.bot,
+                self.config_manager,
+                self.update_checker,
+                self.processor
+            )
             
             # Initialize components for existing guilds
             for guild in self.bot.guilds:
@@ -124,6 +123,10 @@ class VideoArchiver(VideoArchiverCommands):
             # Wait for initialization to complete
             await asyncio.wait_for(self.ready.wait(), timeout=30)
             
+            # Add commands to the bot
+            for command in self.commands_handler.videoarchiver.commands:
+                self.bot.tree.add_command(command)
+            
         except asyncio.TimeoutError:
             await self._cleanup()
             raise ProcessingError("Cog initialization timed out")
@@ -133,6 +136,10 @@ class VideoArchiver(VideoArchiverCommands):
 
     async def cog_unload(self) -> None:
         """Clean up when cog is unloaded"""
+        # Remove commands from the bot
+        for command in self.commands_handler.videoarchiver.commands:
+            self.bot.tree.remove_command(command.name)
+            
         await self._cleanup()
 
     async def _cleanup(self) -> None: