fix: update bot service imports to remove monolith dependencies (#109)

Co-authored-by: Claude <noreply@anthropic.com>

Author: JacobCoffee

Makefile

@@ -117,7 +117,9 @@ coverage:  ## Run the tests and generate coverage report
 	@$(UV) run --no-sync coverage html
 	@$(UV) run --no-sync coverage xml
 
-check-all: lint test fmt-check coverage ## Run all linting, tests, and coverage checks
+check-all: lint type-check fmt test  ## Run all linting, formatting, and tests
+
+ci: check-all  ## Run all checks for CI
 
 # =============================================================================
 # Docs

pyproject.toml

@@ -72,6 +72,7 @@ module-root = ""  # Flat layout: byte_bot/ at root, not src/byte_bot/
 members = [
     "packages/byte-common",
     "services/api",
+    "services/bot",
 ]
 
 [tool.uv]
@@ -177,7 +178,22 @@ filterwarnings = [
 [tool.ty]
 
 [tool.ty.environment]
-extra-paths = ["byte_bot/", "tests/", "packages/byte-common/src/", "packages/byte-common/tests/", "services/api/src/"]
+extra-paths = ["byte_bot/", "tests/", "packages/byte-common/src/", "packages/byte-common/tests/", "services/api/src/", "services/bot/src/"]
+
+# Disable checking for old monolith code that will be removed in Phase 1.2
+# and API service which has separate import issues
+[tool.ty.src]
+exclude = [
+    "byte_bot/__init__.py",
+    "byte_bot/app.py",
+    "byte_bot/cli.py",
+    "byte_bot/utils.py",
+    "byte_bot/__metadata__.py",
+    "byte_bot/byte/**/*.py",
+    "byte_bot/server/**/*.py",
+    "services/api/**/*.py",
+    "docs/conf.py",
+]
 
 [tool.slotscheck]
 strict-imports = false

services/bot/pyproject.toml

@@ -0,0 +1,31 @@
+[project]
+name = "byte-bot-service"
+version = "0.2.0"
+description = "Discord bot service for Byte Bot"
+authors = [
+    { name = "Jacob Coffee", email = "jacob@z7x.org" },
+]
+dependencies = [
+    "byte-common",
+    "discord-py>=2.3.2",
+    "httpx>=0.25.0",
+    "pydantic>=2.5.2",
+    "pydantic-settings>=2.1.0",
+    "python-dotenv>=1.0.0",
+    "anyio>=4.1.0",
+]
+requires-python = ">=3.12,<4.0"
+license = { text = "MIT" }
+
+[project.scripts]
+byte-bot = "byte_bot.__main__:main"
+
+[build-system]
+requires = ["uv_build>=0.9.11,<0.10.0"]
+build-backend = "uv_build"
+
+[tool.uv]
+package = true
+
+[tool.uv.sources]
+byte-common = { workspace = true }

services/bot/src/byte_bot/__init__.py

@@ -0,0 +1,3 @@
+"""Byte Bot - Discord bot service."""
+
+__version__ = "0.2.0"

services/bot/src/byte_bot/__main__.py

@@ -0,0 +1,27 @@
+"""Bot service entrypoint."""
+
+from __future__ import annotations
+
+import sys
+
+__all__ = ("main",)
+
+
+def main() -> None:
+    """Run the Discord bot."""
+    try:
+        from byte_bot.bot import run_bot  # noqa: PLC0415
+    except ImportError as exc:
+        print(  # noqa: T201
+            "Could not load required libraries. "
+            "Please check your installation and make sure you activated any necessary virtual environment.",
+        )
+        print(exc)  # noqa: T201
+        sys.exit(1)
+
+    # Run the bot
+    run_bot()
+
+
+if __name__ == "__main__":
+    main()

services/bot/src/byte_bot/api_client.py

@@ -0,0 +1,250 @@
+"""HTTP client for communicating with the Byte API service."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, Self
+
+import httpx
+
+from byte_common.schemas.guild import CreateGuildRequest, GuildSchema, UpdateGuildRequest
+
+if TYPE_CHECKING:
+    from uuid import UUID
+
+__all__ = ("APIError", "ByteAPIClient")
+
+logger = logging.getLogger(__name__)
+
+# HTTP status codes
+HTTP_NOT_FOUND = 404
+
+
+class APIError(Exception):
+    """Exception raised when API calls fail."""
+
+    def __init__(self, message: str, status_code: int | None = None) -> None:
+        """Initialize API error.
+
+        Args:
+            message: Error message
+            status_code: HTTP status code if available
+        """
+        super().__init__(message)
+        self.status_code = status_code
+
+
+class ByteAPIClient:
+    """HTTP client for Byte API service.
+
+    This client handles all communication between the bot service and the API service,
+    replacing direct database access.
+    """
+
+    def __init__(self, base_url: str, timeout: float = 10.0) -> None:
+        """Initialize API client.
+
+        Args:
+            base_url: Base URL of the API service (e.g., "http://localhost:8000")
+            timeout: Request timeout in seconds
+        """
+        self.base_url = base_url.rstrip("/")
+        self.client = httpx.AsyncClient(
+            base_url=self.base_url,
+            timeout=timeout,
+            headers={"Content-Type": "application/json"},
+        )
+
+    async def close(self) -> None:
+        """Close the HTTP client."""
+        await self.client.aclose()
+
+    async def __aenter__(self) -> Self:
+        """Async context manager entry."""
+        return self
+
+    async def __aexit__(self, *args: object) -> None:
+        """Async context manager exit."""
+        await self.close()
+
+    # Guild Management
+
+    async def create_guild(
+        self,
+        guild_id: int,
+        guild_name: str,
+        prefix: str = "!",
+        **kwargs: Any,
+    ) -> GuildSchema:
+        """Create a new guild.
+
+        Args:
+            guild_id: Discord guild ID
+            guild_name: Discord guild name
+            prefix: Command prefix
+            **kwargs: Additional guild configuration
+
+        Returns:
+            Created guild schema
+
+        Raises:
+            APIError: If the API request fails
+        """
+        request = CreateGuildRequest(
+            guild_id=guild_id,
+            guild_name=guild_name,
+            prefix=prefix,
+            **kwargs,
+        )
+
+        try:
+            response = await self.client.post(
+                "/api/guilds",
+                json=request.model_dump(),
+            )
+            response.raise_for_status()
+            return GuildSchema.model_validate(response.json())
+        except httpx.HTTPStatusError as e:
+            msg = f"Failed to create guild: {e.response.text}"
+            logger.exception(msg, extra={"guild_id": guild_id, "status_code": e.response.status_code})
+            raise APIError(msg, status_code=e.response.status_code) from e
+        except httpx.RequestError as e:
+            msg = f"Failed to connect to API service: {e!s}"
+            logger.exception(msg, extra={"guild_id": guild_id})
+            raise APIError(msg) from e
+
+    async def get_guild(self, guild_id: int) -> GuildSchema | None:
+        """Get guild by Discord ID.
+
+        Args:
+            guild_id: Discord guild ID
+
+        Returns:
+            Guild schema if found, None otherwise
+
+        Raises:
+            APIError: If the API request fails (excluding 404)
+        """
+        try:
+            response = await self.client.get(f"/api/guilds/{guild_id}")
+
+            if response.status_code == HTTP_NOT_FOUND:
+                return None
+
+            response.raise_for_status()
+            return GuildSchema.model_validate(response.json())
+        except httpx.HTTPStatusError as e:
+            msg = f"Failed to get guild: {e.response.text}"
+            logger.exception(msg, extra={"guild_id": guild_id, "status_code": e.response.status_code})
+            raise APIError(msg, status_code=e.response.status_code) from e
+        except httpx.RequestError as e:
+            msg = f"Failed to connect to API service: {e!s}"
+            logger.exception(msg, extra={"guild_id": guild_id})
+            raise APIError(msg) from e
+
+    async def update_guild(
+        self,
+        guild_id: UUID,
+        **updates: Any,
+    ) -> GuildSchema:
+        """Update guild configuration.
+
+        Args:
+            guild_id: Guild UUID (not Discord ID)
+            **updates: Fields to update
+
+        Returns:
+            Updated guild schema
+
+        Raises:
+            APIError: If the API request fails
+        """
+        request = UpdateGuildRequest(**updates)
+
+        try:
+            response = await self.client.patch(
+                f"/api/guilds/{guild_id}",
+                json=request.model_dump(exclude_unset=True),
+            )
+            response.raise_for_status()
+            return GuildSchema.model_validate(response.json())
+        except httpx.HTTPStatusError as e:
+            msg = f"Failed to update guild: {e.response.text}"
+            logger.exception(msg, extra={"guild_id": guild_id, "status_code": e.response.status_code})
+            raise APIError(msg, status_code=e.response.status_code) from e
+        except httpx.RequestError as e:
+            msg = f"Failed to connect to API service: {e!s}"
+            logger.exception(msg, extra={"guild_id": guild_id})
+            raise APIError(msg) from e
+
+    async def delete_guild(self, guild_id: UUID) -> None:
+        """Delete a guild.
+
+        Args:
+            guild_id: Guild UUID (not Discord ID)
+
+        Raises:
+            APIError: If the API request fails
+        """
+        try:
+            response = await self.client.delete(f"/api/guilds/{guild_id}")
+            response.raise_for_status()
+        except httpx.HTTPStatusError as e:
+            msg = f"Failed to delete guild: {e.response.text}"
+            logger.exception(msg, extra={"guild_id": guild_id, "status_code": e.response.status_code})
+            raise APIError(msg, status_code=e.response.status_code) from e
+        except httpx.RequestError as e:
+            msg = f"Failed to connect to API service: {e!s}"
+            logger.exception(msg, extra={"guild_id": guild_id})
+            raise APIError(msg) from e
+
+    async def get_or_create_guild(
+        self,
+        guild_id: int,
+        guild_name: str,
+        prefix: str = "!",
+    ) -> GuildSchema:
+        """Get guild or create if it doesn't exist.
+
+        Args:
+            guild_id: Discord guild ID
+            guild_name: Discord guild name
+            prefix: Command prefix
+
+        Returns:
+            Guild schema
+
+        Raises:
+            APIError: If the API request fails
+        """
+        # Try to get existing guild
+        guild = await self.get_guild(guild_id)
+        if guild is not None:
+            return guild
+
+        # Create new guild
+        return await self.create_guild(
+            guild_id=guild_id,
+            guild_name=guild_name,
+            prefix=prefix,
+        )
+
+    # Health Check
+
+    async def health_check(self) -> dict[str, Any]:
+        """Check API service health.
+
+        Returns:
+            Health check response
+
+        Raises:
+            APIError: If the API is unhealthy
+        """
+        try:
+            response = await self.client.get("/health")
+            response.raise_for_status()
+            return response.json()
+        except (httpx.HTTPStatusError, httpx.RequestError) as e:
+            msg = f"API health check failed: {e!s}"
+            logger.exception(msg)
+            raise APIError(msg) from e