refactor(config): streamline configuration access and remove unused services

- Updated import paths for CONFIG across multiple modules to enhance consistency and maintainability.
- Removed the IConfigService interface and its implementation, simplifying the configuration management.
- Adjusted service registrations and dependency injections to reflect the new configuration structure.
- Enhanced error handling and logging for better diagnostics related to configuration values and service registrations.

Author: kzndotsh

src/tux/core/__init__.py

@@ -16,18 +16,16 @@
     ServiceRegistrationError,
     ServiceResolutionError,
 )
-from tux.core.interfaces import IBotService, IConfigService
+from tux.core.interfaces import IBotService
 from tux.core.service_registry import ServiceRegistry
-from tux.core.services import BotService, ConfigService
+from tux.core.services import BotService
 from tux.database.service import DatabaseService
 
 __all__ = [
     "BaseCog",
     "BotService",
-    "ConfigService",
     "DatabaseService",
     "IBotService",
-    "IConfigService",
     "ServiceContainer",
     "ServiceDescriptor",
     "ServiceLifetime",

src/tux/core/app.py

@@ -22,18 +22,18 @@
 from tux.database.utils import get_db_controller_from
 from tux.help import TuxHelp
 from tux.services.sentry_manager import SentryManager
-from tux.shared.config.settings import CONFIG
+from tux.shared.config import CONFIG
 
 
 async def get_prefix(bot: Tux, message: discord.Message) -> list[str]:
     """Get the command prefix for a guild.
 
     This function retrieves the guild-specific prefix from the database,
-    falling back to `CONFIG.DEFAULT_PREFIX` when the guild is unavailable or the database
+    falling back to `CONFIG.get_prefix()` when the guild is unavailable or the database
     cannot be resolved.
     """
     if not message.guild:
-        return [CONFIG.DEFAULT_PREFIX]
+        return [CONFIG.get_prefix()]
 
     prefix: str | None = None
 
@@ -42,15 +42,22 @@ async def get_prefix(bot: Tux, message: discord.Message) -> list[str]:
         if controller is None:
             logger.warning("Database unavailable; using default prefix")
         else:
-            # Get guild config and extract prefix
-            guild_config = await controller.guild_config.get_config_by_guild_id(message.guild.id)
+            # Ensure the guild exists in the database first
+            await controller.guild.get_or_create_guild(message.guild.id)
+
+            # Get or create guild config with default prefix
+            guild_config = await controller.guild_config.get_or_create_config(
+                message.guild.id,
+                prefix=CONFIG.get_prefix(),  # Use the default prefix as the default value
+            )
             if guild_config and hasattr(guild_config, "prefix"):
                 prefix = guild_config.prefix
 
     except Exception as e:
-        logger.error(f"Error getting guild prefix: {e}")
+        logger.error(f"❌ Error getting guild prefix: {type(e).__name__}")
+        logger.info("💡 Using default prefix due to database or configuration error")
 
-    return [prefix or CONFIG.DEFAULT_PREFIX]
+    return [prefix or CONFIG.get_prefix()]
 
 
 class TuxApp:
@@ -142,18 +149,18 @@ async def start(self) -> None:
         self.setup_signals(loop)
 
         if not CONFIG.BOT_TOKEN:
-            logger.critical("No bot token provided. Set DEV_BOT_TOKEN or PROD_BOT_TOKEN in your .env file.")
-            return
+            logger.critical("No bot token provided. Set BOT_TOKEN in your .env file.")
+            sys.exit(1)
 
-        owner_ids = {CONFIG.BOT_OWNER_ID}
+        owner_ids = {CONFIG.USER_IDS.BOT_OWNER_ID}
 
         if CONFIG.ALLOW_SYSADMINS_EVAL:
             logger.warning(
-                "⚠️ Eval is enabled for sysadmins, this is potentially dangerous; see settings.yml.example for more info.",
+                "⚠️ Eval is enabled for sysadmins, this is potentially dangerous; see .env file for more info.",
             )
-            owner_ids.update(CONFIG.SYSADMIN_IDS)
+            owner_ids.update(CONFIG.USER_IDS.SYSADMINS)
         else:
-            logger.warning("🔒️ Eval is disabled for sysadmins; see settings.yml.example for more info.")
+            logger.warning("🔒️ Eval is disabled for sysadmins; see .env file for more info.")
 
         self.bot = Tux(
             command_prefix=get_prefix,
@@ -176,7 +183,8 @@ async def start(self) -> None:
         except KeyboardInterrupt:
             logger.info("Shutdown requested (KeyboardInterrupt)")
         except Exception as e:
-            logger.critical(f"Bot failed to start: {e}")
+            logger.critical(f"❌ Bot failed to start: {type(e).__name__}")
+            logger.info("💡 Check your configuration and ensure all services are properly set up")
         finally:
             await self.shutdown()
 

src/tux/core/base_cog.py

@@ -16,8 +16,10 @@
 from discord.ext import commands
 from loguru import logger
 
-from tux.core.interfaces import IBotService, IConfigService, ILoggerService
+from tux.core.interfaces import IBotService, ILoggerService
+from tux.database.controllers import DatabaseCoordinator
 from tux.database.service import DatabaseService
+from tux.shared.config import CONFIG
 from tux.shared.functions import generate_usage as _generate_usage_shared
 
 if TYPE_CHECKING:
@@ -51,9 +53,9 @@ def __init__(self, bot: Tux) -> None:
         # Initialize service properties first
         self.db_service: DatabaseService | None = None
         self.bot_service: IBotService | None = None
-        self.config_service: IConfigService | None = None
+
         self.logger_service: ILoggerService | None = None
-        self._db_controller = None  # legacy attribute removed; kept for type stability only
+        self._db_coordinator: DatabaseCoordinator | None = None  # Database coordinator for accessing controllers
 
         # Get the bot instance
         self.bot = bot
@@ -79,24 +81,25 @@ def _inject_services(self) -> None:
         # Inject services in order of dependency
         self._inject_database_service()
         self._inject_bot_service()
-        self._inject_config_service()
+
         self._inject_logger_service()
 
         # Single summary log for this cog's injection results
         logger.debug(
             f"[BaseCog] Injected services for {self.__class__.__name__} "
             f"(db={self.db_service is not None}, "
             f"bot={self.bot_service is not None}, "
-            f"config={self.config_service is not None}, "
             f"logger={self.logger_service is not None})",
         )
 
     def _inject_database_service(self) -> None:
-        """Inject the database service."""
+        """Inject the database service and create database coordinator."""
         try:
             self.db_service = self._container.get_optional(DatabaseService)
             if self.db_service:
-                logger.trace(f"Injected database service into {self.__class__.__name__}")
+                # Create the database coordinator for accessing controllers
+                self._db_coordinator = DatabaseCoordinator(self.db_service)
+                logger.trace(f"Injected database service and coordinator into {self.__class__.__name__}")
             else:
                 logger.warning(f"Database service not available for {self.__class__.__name__}")
         except Exception as e:
@@ -113,17 +116,6 @@ def _inject_bot_service(self) -> None:
         except Exception as e:
             logger.error(f"[BaseCog] Bot service injection failed for {self.__class__.__name__}: {e}", exc_info=True)
 
-    def _inject_config_service(self) -> None:
-        """Inject the config service."""
-        try:
-            self.config_service = self._container.get_optional(IConfigService)
-            if self.config_service:
-                logger.trace(f"Injected config service into {self.__class__.__name__}")
-            else:
-                logger.warning(f"Config service not available for {self.__class__.__name__}")
-        except Exception as e:
-            logger.error(f"Config service injection failed for {self.__class__.__name__}: {e}")
-
     def _inject_logger_service(self) -> None:
         """Inject the logger service (optional)."""
         try:
@@ -190,36 +182,46 @@ def _generate_usage(self, command: commands.Command[Any, ..., Any]) -> str:
     # (Embed helpers and error handling intentionally omitted as requested.)
 
     @property
-    def db(self):
-        """Get the database controller from the injected database service.
+    def db(self) -> DatabaseCoordinator:
+        """Get the database coordinator for accessing database controllers.
 
         Returns:
-            The database controller instance
+            The database coordinator instance
 
         Raises:
-            RuntimeError: If the database service is not available
+            RuntimeError: If the database coordinator is not available
         """
-        if self.db_service is None:
-            error_msg = "Database service not injected. DI is required."
+        if self._db_coordinator is None:
+            error_msg = "Database coordinator not available. DI is required."
             raise RuntimeError(error_msg)
-        return self.db_service
+        return self._db_coordinator
 
     def get_config(self, key: str, default: Any = None) -> Any:
-        """Get a configuration value with service injection support.
+        """Get a configuration value directly from CONFIG.
 
         Args:
             key: The configuration key to retrieve
             default: Default value if key is not found
 
         Returns:
             The configuration value or default
-
-        This method uses the injected config service only.
         """
-        if self.config_service is None:
-            error_msg = "Config service not injected. DI is required."
-            raise RuntimeError(error_msg)
-        return self.config_service.get(key, default)
+
+        try:
+            # Handle nested keys like "BOT_INFO.BOT_NAME"
+            keys = key.split(".")
+            value = CONFIG
+
+            for k in keys:
+                if hasattr(value, k):
+                    value = getattr(value, k)
+                else:
+                    return default
+        except Exception as e:
+            logger.error(f"Failed to get config value {key}: {e}")
+            return default
+        else:
+            return value
 
     def get_bot_latency(self) -> float:
         """Get the bot's latency with service injection support.