agentirc 1.0.0__py3-none-any.whl

agentirc/history.py

@@ -0,0 +1,202 @@
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Dict, List, Optional
+
+log = logging.getLogger(__name__)
+
+
+class HistoryStore:
+    """In-memory history per room and user with system prompt support.
+
+    Optionally persists to an encrypted file when *store_path* and
+    *encryption_key* are both provided.
+    """
+
+    def __init__(
+        self,
+        prompt_prefix: str = "you are ",
+        prompt_suffix: str = ".",
+        personality: str = "",
+        *,
+        prompt_suffix_extra: str = "",
+        max_items: int = 24,
+        history_size: Optional[int] = None,
+        system_prompt: Optional[str] = None,
+        store_path: Optional[str] = None,
+        encryption_key: Optional[str] = None,
+    ) -> None:
+        if system_prompt is not None:
+            self.prompt_prefix = ""
+            self.prompt_suffix = ""
+            self.prompt_suffix_extra = ""
+            self.personality = ""
+            self._fixed_system_prompt = system_prompt
+        else:
+            self.prompt_prefix = prompt_prefix
+            self.prompt_suffix = prompt_suffix
+            self.prompt_suffix_extra = prompt_suffix_extra
+            self.personality = personality
+            self._fixed_system_prompt = None
+        self.max_items = history_size or max_items
+        self._include_extra = True
+        self._messages: Dict[str, Dict[str, List[Dict[str, str]]]] = {}
+        self._locations: Dict[str, str] = {}
+        self.user_models: Dict[str, Dict[str, str]] = {}
+
+        # Encrypted persistence setup
+        self._fernet = None
+        self._store_file: Optional[Path] = None
+        if store_path and encryption_key:
+            try:
+                from cryptography.fernet import Fernet
+                self._fernet = Fernet(encryption_key.encode() if isinstance(encryption_key, str) else encryption_key)
+                self._store_file = Path(store_path) / "history.enc"
+                self._store_file.parent.mkdir(parents=True, exist_ok=True)
+                self._load()
+            except Exception:
+                log.exception("Failed to initialize encrypted persistence")
+                self._fernet = None
+                self._store_file = None
+
+    @property
+    def messages(self) -> Dict[str, Dict[str, List[Dict[str, str]]]]:
+        return self._messages
+
+    def set_verbose(self, verbose: bool) -> None:
+        self._include_extra = not bool(verbose)
+
+    def _full_suffix(self) -> str:
+        extra = self.prompt_suffix_extra if self._include_extra and self.prompt_suffix_extra else ""
+        return f"{self.prompt_suffix}{extra}"
+
+    def _location_suffix(self, user: str) -> str:
+        loc = self._locations.get(user, "")
+        if loc:
+            return f" The user has indicated they are located in {loc}.  Use when needed, Do not adopt this as part of your personality."
+        return ""
+
+    def _system_for(self, room: str, user: str) -> str:
+        del room
+        if self._fixed_system_prompt is not None:
+            return self._fixed_system_prompt + self._location_suffix(user)
+        return f"{self.prompt_prefix}{self.personality}{self._full_suffix()}{self._location_suffix(user)}"
+
+    def _ensure(self, room: str, user: str) -> None:
+        if room not in self._messages:
+            self._messages[room] = {}
+        if user not in self._messages[room]:
+            self._messages[room][user] = [{"role": "system", "content": self._system_for(room, user)}]
+
+    def init_prompt(
+        self,
+        room: str,
+        user: str,
+        persona: Optional[str] = None,
+        custom: Optional[str] = None,
+    ) -> None:
+        self._ensure(room, user)
+        loc_suffix = self._location_suffix(user)
+        if custom:
+            self._messages[room][user] = [{"role": "system", "content": custom + loc_suffix}]
+        else:
+            p = persona if (persona is not None and persona != "") else self.personality
+            self._messages[room][user] = [
+                {"role": "system", "content": f"{self.prompt_prefix}{p}{self._full_suffix()}{loc_suffix}"}
+            ]
+        self._save()
+
+    def add(self, room: str, user: str, role: str, content: str) -> None:
+        self._ensure(room, user)
+        self._messages[room][user].append({"role": role, "content": content})
+        self._trim(room, user)
+        self._save()
+
+    def get(self, room: str, user: str) -> List[Dict[str, str]]:
+        self._ensure(room, user)
+        return list(self._messages[room][user])
+
+    def reset(self, room: str, user: str, stock: bool = False) -> None:
+        if room not in self._messages:
+            self._messages[room] = {}
+        self._messages[room][user] = []
+        if not stock:
+            self.init_prompt(room, user, persona=self.personality)
+        self._save()
+
+    def clear(self, room: str, user: str) -> None:
+        self.reset(room, user, stock=True)
+
+    def clear_all(self) -> None:
+        self._messages.clear()
+        # Locations are user preferences, not conversation state — preserve them
+        self._save()
+
+    def set_location(self, user: str, location: str) -> None:
+        """Set or clear a user's location. Updates system prompts in all existing threads."""
+        old_suffix = self._location_suffix(user)
+        if location:
+            self._locations[user] = location
+        else:
+            self._locations.pop(user, None)
+        new_suffix = self._location_suffix(user)
+
+        # Update system prompts in all existing threads for this user
+        for room in self._messages:
+            if user in self._messages[room]:
+                msgs = self._messages[room][user]
+                if msgs and msgs[0].get("role") == "system":
+                    content = msgs[0]["content"]
+                    if old_suffix:
+                        content = content.replace(old_suffix, "")
+                    content = content + new_suffix
+                    msgs[0]["content"] = content
+        self._save()
+
+    def get_location(self, user: str) -> Optional[str]:
+        return self._locations.get(user) or None
+
+    def _trim(self, room: str, user: str) -> None:
+        msgs = self._messages[room][user]
+        while len(msgs) > self.max_items:
+            if msgs and msgs[0].get("role") == "system":
+                if len(msgs) > 1:
+                    msgs.pop(1)
+                else:
+                    break
+            else:
+                msgs.pop(0)
+
+    def _save(self) -> None:
+        if not self._fernet or not self._store_file:
+            return
+        try:
+            data = json.dumps({
+                "messages": self._messages,
+                "locations": self._locations,
+            })
+            encrypted = self._fernet.encrypt(data.encode())
+            self._store_file.write_bytes(encrypted)
+        except Exception:
+            log.exception("Failed to save encrypted history")
+
+    def _load(self) -> None:
+        if not self._fernet or not self._store_file or not self._store_file.exists():
+            return
+        try:
+            encrypted = self._store_file.read_bytes()
+            decrypted = self._fernet.decrypt(encrypted)
+            data = json.loads(decrypted.decode())
+            if isinstance(data, dict):
+                if "messages" in data:
+                    self._messages = data["messages"]
+                    self._locations = data.get("locations", {})
+                else:
+                    # Old format: bare messages dict
+                    self._messages = data
+        except Exception:
+            log.exception("Failed to load encrypted history (wrong key?), starting fresh")
+            self._messages = {}
+            self._locations = {}

agentirc/models.py

@@ -0,0 +1,156 @@
+"""Model discovery and provider resolution helpers."""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+from urllib.error import URLError
+from urllib.request import Request, urlopen
+
+log = logging.getLogger(__name__)
+
+KNOWN_PROVIDERS = ("openai", "xai", "lmstudio")
+
+
+def _models_url(api_base: str) -> str:
+    base = api_base.rstrip("/")
+    return f"{base}/models" if base.endswith("/v1") else f"{base}/v1/models"
+
+
+def _is_chat_model(provider: str, model_id: str) -> bool:
+    lowered = model_id.lower()
+    if provider == "lmstudio":
+        blocked_models = {
+            "text-embedding-nomic-embed-text-v1.5",
+        }
+        if lowered in blocked_models:
+            return False
+        return bool(model_id.strip())
+
+    if provider == "xai":
+        if not lowered.startswith("grok-"):
+            return False
+        blocked_fragments = ("imagine", "image", "video", "voice", "vision")
+        return not any(fragment in lowered for fragment in blocked_fragments)
+
+    prefixes = ("gpt-", "o1", "o3", "o4")
+    if not model_id.startswith(prefixes):
+        return False
+
+    blocked_fragments = (
+        "preview",
+        "audio",
+        "computer-use",
+        "transcribe",
+        "tts",
+        "image",
+    )
+    if any(fragment in lowered for fragment in blocked_fragments):
+        return False
+
+    if re.search(r"-\d{4}-\d{2}-\d{2}$", lowered):
+        return False
+
+    return True
+
+
+def provider_for_model(model: str, models: dict[str, list[str]]) -> str | None:
+    selected = str(model or "").strip()
+    if not selected:
+        return None
+
+    for provider, provider_models in models.items():
+        if selected in provider_models:
+            return provider
+
+    lowered = selected.lower()
+    if lowered.startswith("grok-"):
+        return "xai"
+    if lowered.startswith(("gpt-", "o1", "o3", "o4")):
+        return "openai"
+    return None
+
+
+def fetch_models(api_base: str, api_key: str = "", provider: str = "openai") -> list[str]:
+    """GET models and return filtered chat-capable model IDs."""
+    url = _models_url(api_base)
+    req = Request(url, method="GET")
+    if api_key:
+        req.add_header("Authorization", f"Bearer {api_key}")
+
+    try:
+        with urlopen(req, timeout=30) as resp:
+            body = json.loads(resp.read())
+    except (URLError, OSError, json.JSONDecodeError) as exc:
+        log.error("Failed to fetch models from %s: %s", url, exc)
+        return []
+
+    models = [m["id"] for m in body.get("data", []) if isinstance(m, dict) and "id" in m]
+    models = [m for m in models if _is_chat_model(provider, m)]
+    models.sort()
+    return models
+
+
+def refresh_model_catalog(
+    configured_models: dict[str, list[str]],
+    *,
+    base_urls: dict[str, str],
+    api_keys: dict[str, str],
+    server_models: bool = True,
+) -> dict[str, list[str]]:
+    """Build a provider->models map from config and optional server discovery."""
+    merged: dict[str, list[str]] = {
+        provider: sorted(dict.fromkeys(configured_models.get(provider, [])))
+        for provider in KNOWN_PROVIDERS
+    }
+
+    if not server_models:
+        return merged
+
+    for provider in KNOWN_PROVIDERS:
+        api_base = str(base_urls.get(provider, "") or "").strip()
+        if not api_base:
+            continue
+
+        api_key = str(api_keys.get(provider, "") or "").strip()
+
+        fetched = fetch_models(api_base, api_key, provider=provider)
+        if not fetched:
+            continue
+
+        merged[provider] = sorted(dict.fromkeys([*merged[provider], *fetched]))
+
+    return merged
+
+
+def pick_default_model(models: dict[str, list[str]], preferred: str = "") -> str:
+    """Select a default model from preferred value or the catalog."""
+    preferred = preferred.strip()
+    if preferred:
+        return preferred
+
+    for provider in KNOWN_PROVIDERS:
+        items = models.get(provider, [])
+        if items:
+            return items[0]
+    raise RuntimeError("No models available from configured providers")
+
+
+def pick_model(api_base: str, api_key: str = "", preferred: str = "", provider: str = "openai") -> str:
+    """Legacy helper: pick a model from a single provider endpoint."""
+    available = fetch_models(api_base, api_key, provider=provider)
+
+    if available:
+        log.debug("Available models: %s", ", ".join(available))
+        if preferred and preferred in available:
+            return preferred
+        if preferred:
+            log.warning("Preferred model %r not found, using %s", preferred, available[0])
+        return available[0]
+
+    if preferred:
+        log.warning("Could not fetch models from %s, using preferred model %r", api_base, preferred)
+        return preferred
+
+    raise RuntimeError(f"No models available from {api_base}")

agentirc/tools.py

@@ -0,0 +1,81 @@
+"""Tool definitions for OpenAI-compatible Responses APIs."""
+
+from __future__ import annotations
+
+from typing import Any
+
+XAI_HOSTED_TOOL_TYPES = {"web_search", "x_search", "code_interpreter", "mcp"}
+
+
+def build_tools(
+    enabled: list[str],
+    provider: str = "openai",
+    *,
+    web_search_country: str = "",
+) -> list[dict[str, Any]]:
+    """Build the tools list for the Responses API request.
+
+    Supported tools:
+        - web_search (openai, xai)
+        - x_search (xai)
+        - code_interpreter (openai, xai)
+    """
+    tool_builders: dict[str, tuple[set[str], Any]] = {
+        "web_search": ({"openai", "xai"}, _web_search_tool),
+        "x_search": ({"xai"}, _x_search_tool),
+        "code_interpreter": ({"openai", "xai"}, _code_interpreter_tool),
+    }
+
+    tools = []
+    for name in enabled:
+        spec = tool_builders.get(name)
+        if not spec:
+            continue
+        providers, builder = spec
+        if provider in providers:
+            if name == "web_search":
+                tools.append(builder(provider, country=web_search_country))
+            else:
+                tools.append(builder(provider))
+    return tools
+
+
+def _web_search_tool(_provider: str, *, country: str = "") -> dict[str, Any]:
+    tool: dict[str, Any] = {"type": "web_search"}
+    if country:
+        tool["user_location"] = {"type": "approximate", "country": country}
+    return tool
+
+
+def strip_search_country(tools: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """Remove user_location from web_search tool dicts."""
+    result = []
+    for tool in tools:
+        if isinstance(tool, dict) and tool.get("type") == "web_search" and "user_location" in tool:
+            tool = {k: v for k, v in tool.items() if k != "user_location"}
+        result.append(tool)
+    return result
+
+
+def _x_search_tool(_provider: str) -> dict[str, Any]:
+    return {"type": "x_search"}
+
+
+def _code_interpreter_tool(provider: str) -> dict[str, Any]:
+    tool = {"type": "code_interpreter"}
+    if provider == "openai":
+        tool["container"] = {"type": "auto"}
+    return tool
+
+
+def xai_model_supports_hosted_tools(model: str) -> bool:
+    lowered = str(model or "").strip().lower()
+    return lowered.startswith("grok-4")
+
+
+def tools_for_model(enabled: list[str], provider: str, model: str) -> list[str]:
+    if provider != "xai":
+        return list(enabled)
+    if xai_model_supports_hosted_tools(model):
+        return list(enabled)
+    return [name for name in enabled if name not in XAI_HOSTED_TOOL_TYPES]

agentirc-1.0.0.dist-info/METADATA

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: agentirc
+Version: 1.0.0
+Summary: AI-powered IRC agent with multi-provider LLM support
+Project-URL: Homepage, https://github.com/h1ddenpr0cess20/agentirc
+Project-URL: Repository, https://github.com/h1ddenpr0cess20/agentirc
+Project-URL: Issues, https://github.com/h1ddenpr0cess20/agentirc/issues
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agent,ai,bot,chatbot,irc,llm,ollama,openai
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Communications :: Chat
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Provides-Extra: crypto
+Requires-Dist: cryptography>=43; extra == 'crypto'
+Description-Content-Type: text/markdown
+
+# agentirc
+
+An AI-powered IRC agent built on a minimal async IRC bot framework. Supports multiple LLM providers (OpenAI, xAI, LM Studio) with per-user conversation history, tool use, and encrypted persistence.
+
+## Table of Contents
+
+- [Quick Start](#quick-start)
+- [CLI Options](#cli-options)
+- [Commands](#commands)
+- [Documentation](#documentation)
+- [License](#license)
+
+## Quick Start
+
+```bash
+git clone <repo-url>
+cd agentirc
+cp .env.example .env
+# Edit .env with your IRC server, nick, and at least one API provider
+pip install .
+agentirc
+```
+
+Or with Docker:
+
+```bash
+cp .env.example .env
+# Edit .env
+docker compose up -d
+```
+
+> **Requirements:** Python 3.10+, `httpx`, and optionally `cryptography` for encrypted history persistence.
+
+## CLI Options
+
+```
+agentirc [options]
+```
+
+| Flag | Description |
+|---|---|
+| `--env-file PATH` | Path to .env file (default: `.env`) |
+| `--debug` | Enable debug logging |
+| `--host HOST` | IRC server hostname (overrides `IRC_HOST`) |
+| `--port PORT` | IRC server port (overrides `IRC_PORT`) |
+| `--nick NICK` | Bot nickname (overrides `IRC_NICK`) |
+| `--channels CHANS` | Comma-separated channels (overrides `IRC_CHANNELS`) |
+| `--tls` | Connect with TLS (overrides `IRC_USE_TLS`) |
+| `--model MODEL` | Default model (overrides `DEFAULT_MODEL`) |
+| `--generate-key` | Generate a Fernet encryption key and exit |
+
+CLI flags override their corresponding environment variables.
+
+## Commands
+
+### User Commands
+
+| Command | Aliases | Description |
+|---|---|---|
+| `!ai <message>` | `!chat`, `!ask` | Talk to the AI |
+| `!persona <text>` | | Set a persona and reintroduce |
+| `!custom <prompt>` | | Set a custom system prompt |
+| `!reset` | | Reset conversation to defaults |
+| `!stock` | | Reset conversation with no system prompt |
+| `!mymodel [name]` | | Show or set your model |
+| `!location <place>` | | Set your location for contextual answers |
+| `!x <nick> <message>` | | Talk as another user |
+
+### Admin Commands
+
+| Command | Description |
+|---|---|
+| `!model [name\|reset]` | Show/set global default model |
+| `!tools [on\|off\|toggle\|status]` | Enable/disable tool use |
+| `!verbose [on\|off\|toggle]` | Toggle verbose mode |
+| `!clear` | Clear all conversation state |
+| `!country [on\|off\|status]` | Toggle search country filtering |
+| `!join <#channel>` | Join a channel |
+| `!part [#channel] [reason]` | Leave a channel |
+
+Built-in IRC commands (`!ping`, `!time`, `!help`) are also available.
+
+## Documentation
+
+- [docs/configuration.md](docs/configuration.md) -- IRC and AI provider configuration
+- [docs/commands.md](docs/commands.md) -- command registry and decorator API
+- [docs/extending.md](docs/extending.md) -- subclassing IRCBot, event hooks
+- [docs/ai-agent.md](docs/ai-agent.md) -- AI agent architecture, providers, tools, and history
+- [docs/ai-output-disclaimer.md](docs/ai-output-disclaimer.md) -- AI output disclaimer and conditions of use
+- [docs/not-a-companion.md](docs/not-a-companion.md) -- project scope and intended use
+
+## License
+
+MIT

agentirc-1.0.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+agentirc/__init__.py,sha256=vS8FZZv7cTGYip0sDOB5R3AKQ7n9YFed-wpMhpoX2tI,184
+agentirc/__main__.py,sha256=_55sP49N9gEe5frnCdRP8XFl69MeGPvLmqUIPvo1LYQ,2519
+agentirc/api.py,sha256=R8vDxuNZDw57FE1F78Ffuxit6v85JfiS2zAEQO9Iaic,13353
+agentirc/bot.py,sha256=GqRw6HmT-ldxcyJQI5I1znI7kx6ObVvE2agUuJ6N4Sg,18636
+agentirc/config.py,sha256=h1gH2GFTk9l0XCIW36aEnoWcKBIgGDbsZIUzNDH-7UE,4853
+agentirc/history.py,sha256=GVAU6HtINVw4plS5QCDUIWC3R4IBw1rOMS5-_T8n8yo,7712
+agentirc/models.py,sha256=tOo-CgwxjG2hVrliEZF-c974sHuKQNw1bQSLJXvylP8,4749
+agentirc/tools.py,sha256=tX7z0dCDJNlxOHMtKsoKZZNIPm_9s--m-mCRZYzIq0g,2513
+ircbot/__init__.py,sha256=jOY4I9BbKkn3jxao1ntiY_0q8D60jQT4gb9mGY4r95s,317
+ircbot/__main__.py,sha256=I_VQkjDLvL4w5lFrMUAdfL94mK86vwNjHwE2PGy9EhU,1011
+ircbot/bot.py,sha256=KQhANH06TkSBetOthlOiT9Y0fuaOzGCgg2oI7ZKANCY,9265
+ircbot/commands.py,sha256=nyPmFgJceRuZKNKP7bD45DcwiLRlPY7QNWGD5wJnqCI,1789
+ircbot/config.py,sha256=4GL5EXjHJlMd9yQX-yAK2vBJwAuab-7X-R8hsrn9cx8,2078
+ircbot/connection.py,sha256=yMvpALcTxAySWiSEMOGB8jOdHxq3O5EN9_2rOZFBtRA,4066
+ircbot/protocol.py,sha256=_ytYwsLS56FHVbXxn1HsO5-I9yFtsykbSSo7bztJxqw,2725
+agentirc-1.0.0.dist-info/METADATA,sha256=WxIezdIRn87Fg2h_cCwvoVm64O9jUdRsLjF7VXslfnQ,3862
+agentirc-1.0.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+agentirc-1.0.0.dist-info/entry_points.txt,sha256=4NGgML7IAdbX-kAWU-sbDnIGr6GBZmABuFQAcJXW2cA,52
+agentirc-1.0.0.dist-info/licenses/LICENSE,sha256=Z7RUccYKYBtqgZ6na1vsF5vZO7NYP9EoD9Km9pGE_Xo,1069
+agentirc-1.0.0.dist-info/RECORD,,

agentirc-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

agentirc-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+agentirc = agentirc.__main__:main

agentirc-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dustin Whyte
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ircbot/__init__.py

@@ -0,0 +1,15 @@
+"""ircbot -- async IRC bot framework, stdlib only."""
+
+from .bot import IRCBot
+from .config import BotConfig, load_env
+from .protocol import IRCMessage, parse
+from .commands import register_builtins
+
+__all__ = [
+    "IRCBot",
+    "BotConfig",
+    "IRCMessage",
+    "load_env",
+    "parse",
+    "register_builtins",
+]

ircbot/__main__.py

@@ -0,0 +1,41 @@
+"""Entry point: python -m ircbot"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import sys
+
+from .config import load_env, BotConfig
+from .bot import IRCBot
+from .commands import register_builtins
+
+
+def setup_logging() -> None:
+    """Configure stdlib logging with a clean format."""
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+        stream=sys.stderr,
+    )
+    # Quiet down the debug-level line logging unless DEBUG is set
+    logging.getLogger("ircbot.connection").setLevel(
+        logging.DEBUG if "--debug" in sys.argv else logging.INFO
+    )
+
+
+async def main() -> None:
+    load_env()
+    config = BotConfig.from_env()
+    bot = IRCBot(config)
+    register_builtins(bot)
+    await bot.run()
+
+
+if __name__ == "__main__":
+    setup_logging()
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        logging.getLogger(__name__).info("Shutting down.")