glaip-sdk 0.7.0__py3-none-any.whl → 0.7.2__py3-none-any.whl

glaip_sdk/cli/slash/accounts_controller.py

@@ -170,7 +170,9 @@ class AccountsController:
         callbacks = AccountsTUICallbacks(switch_account=_switch_in_textual)
         active = next((row["name"] for row in rows if row.get("active")), None)
         try:
-            run_accounts_textual(rows, active_account=active, env_lock=env_lock, callbacks=callbacks)
+            # Inject TUI context for theme support
+            tui_ctx = getattr(self.session, "tui_ctx", None)
+            run_accounts_textual(rows, active_account=active, env_lock=env_lock, callbacks=callbacks, ctx=tui_ctx)
         except Exception as exc:  # pragma: no cover - defensive around Textual failures
             self.console.print(f"[{WARNING_STYLE}]Accounts browser exited unexpectedly: {exc}[/]")
 

glaip_sdk/cli/slash/session.py

@@ -6,6 +6,7 @@ Authors:
 
 from __future__ import annotations
 
+import asyncio
 import importlib
 import os
 import shlex
@@ -51,6 +52,7 @@ from glaip_sdk.cli.slash.prompt import (
     to_formatted_text,
 )
 from glaip_sdk.cli.slash.remote_runs_controller import RemoteRunsController
+from glaip_sdk.cli.slash.tui.context import TUIContext
 from glaip_sdk.cli.transcript import (
     export_cached_transcript,
     load_history_snapshot,
@@ -186,6 +188,7 @@ class SlashSession:
         self._update_notifier = maybe_notify_update
         self._home_hint_shown = False
         self._agent_transcript_ready: dict[str, str] = {}
+        self.tui_ctx: TUIContext | None = None
 
     # ------------------------------------------------------------------
     # Session orchestration
@@ -215,6 +218,22 @@ class SlashSession:
 
     def run(self, initial_commands: Iterable[str] | None = None) -> None:
         """Start the command palette session loop."""
+        # Initialize TUI context asynchronously
+        try:
+            self.tui_ctx = asyncio.run(TUIContext.create())
+        except RuntimeError:
+            try:
+                loop = asyncio.get_event_loop()
+            except RuntimeError:
+                self.tui_ctx = None
+            else:
+                if loop.is_running():
+                    self.tui_ctx = None
+                else:
+                    self.tui_ctx = loop.run_until_complete(TUIContext.create())
+        except Exception:
+            self.tui_ctx = None
+
         ctx_obj = self.ctx.obj if isinstance(self.ctx.obj, dict) else None
         previous_session = None
         if ctx_obj is not None:

glaip_sdk/cli/slash/tui/__init__.py

@@ -1,6 +1,14 @@
 """Textual UI helpers for slash commands."""
 
+from glaip_sdk.cli.slash.tui.clipboard import ClipboardAdapter, ClipboardResult
 from glaip_sdk.cli.slash.tui.context import TUIContext
+from glaip_sdk.cli.slash.tui.keybind_registry import (
+    Keybind,
+    KeybindRegistry,
+    format_key_sequence,
+    parse_key_sequence,
+)
+from glaip_sdk.cli.slash.tui.toast import ToastBus, ToastVariant
 from glaip_sdk.cli.slash.tui.remote_runs_app import (
     RemoteRunsTextualApp,
     RemoteRunsTUICallbacks,
@@ -10,9 +18,17 @@ from glaip_sdk.cli.slash.tui.terminal import TerminalCapabilities, detect_termin
 
 __all__ = [
     "TUIContext",
+    "ToastBus",
+    "ToastVariant",
     "TerminalCapabilities",
     "detect_terminal_background",
     "RemoteRunsTextualApp",
     "RemoteRunsTUICallbacks",
     "run_remote_runs_textual",
+    "KeybindRegistry",
+    "Keybind",
+    "parse_key_sequence",
+    "format_key_sequence",
+    "ClipboardAdapter",
+    "ClipboardResult",
 ]

glaip_sdk/cli/slash/tui/accounts.tcss

@@ -11,7 +11,7 @@
 
 #env-lock {
     padding: 0 1 0 1;
-    color: yellow;
+    color: $warning;
     height: 1;
 }
 
@@ -45,6 +45,7 @@
     padding: 0 1 0 1;
     margin: 0 0 0 0;
     height: 1fr;
+    border: tall $primary;
 }
 
 #status-bar {
@@ -58,11 +59,12 @@
 }
 
 #status {
-    padding: 0 1 0 1;
-    margin: 0;
-    color: cyan;
+    height: 3;
+    padding: 0 1;
+    color: $secondary;
 }
 
+
 .form-label {
     padding: 0 1 0 1;
 }
@@ -73,7 +75,7 @@
 
 #form-status, #confirm-status {
     padding: 0 1;
-    color: yellow;
+    color: $warning;
 }
 
 #form-test {

glaip_sdk/cli/slash/tui/accounts_app.py

@@ -23,7 +23,10 @@ from glaip_sdk.cli.slash.accounts_shared import (
     env_credentials_present,
 )
 from glaip_sdk.cli.slash.tui.background_tasks import BackgroundTaskMixin
+from glaip_sdk.cli.slash.tui.clipboard import ClipboardAdapter
+from glaip_sdk.cli.slash.tui.context import TUIContext
 from glaip_sdk.cli.slash.tui.loading import hide_loading_indicator, show_loading_indicator
+from glaip_sdk.cli.slash.tui.theme.catalog import _BUILTIN_THEMES
 from glaip_sdk.cli.validators import validate_api_key
 from glaip_sdk.utils.validation import validate_url
 
@@ -51,6 +54,13 @@ except Exception:  # pragma: no cover - optional dependency
     LoadingIndicator = None  # type: ignore[assignment]
     ModalScreen = None  # type: ignore[assignment]
     Static = None  # type: ignore[assignment]
+    Theme = None  # type: ignore[assignment]
+
+if App is not None:
+    try:  # pragma: no cover - optional dependency
+        from textual.theme import Theme
+    except Exception:  # pragma: no cover - optional dependency
+        Theme = None  # type: ignore[assignment]
 
 TEXTUAL_SUPPORTED = App is not None and DataTable is not None
 
@@ -201,11 +211,12 @@ def run_accounts_textual(
     active_account: str | None,
     env_lock: bool,
     callbacks: AccountsTUICallbacks,
+    ctx: TUIContext | None = None,
 ) -> None:
     """Launch the Textual accounts browser if dependencies are available."""
     if not TEXTUAL_SUPPORTED:
         return
-    app = AccountsTextualApp(rows, active_account, env_lock, callbacks)
+    app = AccountsTextualApp(rows, active_account, env_lock, callbacks, ctx=ctx)
     app.run()
 
 
@@ -379,16 +390,18 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
 
     CSS_PATH = CSS_FILE_NAME
     BINDINGS = [
-        Binding("enter", "switch_row", "Switch", show=True),
-        Binding("return", "switch_row", "Switch", show=False),
-        Binding("/", "focus_filter", "Filter", show=True),
-        Binding("a", "add_account", "Add", show=True),
-        Binding("e", "edit_account", "Edit", show=True),
-        Binding("d", "delete_account", "Delete", show=True),
+        Binding("enter", "switch_row", "Switch", show=True) if Binding else None,
+        Binding("return", "switch_row", "Switch", show=False) if Binding else None,
+        Binding("/", "focus_filter", "Filter", show=True) if Binding else None,
+        Binding("a", "add_account", "Add", show=True) if Binding else None,
+        Binding("e", "edit_account", "Edit", show=True) if Binding else None,
+        Binding("d", "delete_account", "Delete", show=True) if Binding else None,
+        Binding("c", "copy_account", "Copy", show=True) if Binding else None,
         # Esc clears filter when focused/non-empty; otherwise exits
-        Binding("escape", "clear_or_exit", "Close", priority=True),
-        Binding("q", "app_exit", "Close", priority=True),
+        Binding("escape", "clear_or_exit", "Close", priority=True) if Binding else None,
+        Binding("q", "app_exit", "Close", priority=True) if Binding else None,
     ]
+    BINDINGS = [b for b in BINDINGS if b is not None]
 
     def __init__(
         self,
@@ -396,6 +409,7 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
         active_account: str | None,
         env_lock: bool,
         callbacks: AccountsTUICallbacks,
+        ctx: TUIContext | None = None,
     ) -> None:
         """Initialize the Textual accounts app.
 
@@ -404,6 +418,7 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
             active_account: Name of the currently active account.
             env_lock: Whether environment credentials are locking account switching.
             callbacks: Callbacks for account switching operations.
+            ctx: Shared TUI context.
         """
         super().__init__()
         self._store = get_account_store()
@@ -411,6 +426,7 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
         self._active_account = active_account
         self._env_lock = env_lock
         self._callbacks = callbacks
+        self._ctx = ctx
         self._filter_text: str = ""
         self._is_switching = False
 
@@ -449,6 +465,7 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
 
     def on_mount(self) -> None:
         """Configure table columns and load rows."""
+        self._apply_theme()
         table = self.query_one(ACCOUNTS_TABLE_ID, DataTable)
         table.add_column("Name", width=20)
         table.add_column("API URL", width=40)
@@ -752,6 +769,26 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
             return
         self.push_screen(ConfirmDeleteModal(name), self._on_delete_result)
 
+    def action_copy_account(self) -> None:
+        """Copy selected account name and URL to clipboard."""
+        name = self._get_selected_name()
+        if not name:
+            self._set_status("Select an account to copy.", "yellow")
+            return
+
+        account = self._store.get_account(name)
+        if not account:
+            return
+
+        text = f"Account: {name}\nURL: {account.get('api_url', '')}"
+        adapter = ClipboardAdapter()
+        result = adapter.copy(text)
+
+        if result.success:
+            self._set_status(f"Copied '{name}' to clipboard.", "green")
+        else:
+            self._set_status(f"Copy failed: {result.message}", "red")
+
     def _check_env_lock_hotkey(self) -> bool:
         """Prevent mutations when env credentials are present."""
         if not self._is_env_locked():
@@ -874,3 +911,23 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
         filter_input = self.query_one(FILTER_INPUT_ID, Input)
         clear_btn = self.query_one("#filter-clear", Button)
         clear_btn.display = bool(filter_input.value or self._filter_text)
+
+    def _apply_theme(self) -> None:
+        """Register built-in themes and set the active one from context."""
+        if not self._ctx or not self._ctx.theme or Theme is None:
+            return
+
+        for name, tokens in _BUILTIN_THEMES.items():
+            self.register_theme(
+                Theme(
+                    name=name,
+                    primary=tokens.primary,
+                    secondary=tokens.secondary,
+                    accent=tokens.accent,
+                    warning=tokens.warning,
+                    error=tokens.error,
+                    success=tokens.success,
+                )
+            )
+
+        self.theme = self._ctx.theme.theme_name

glaip_sdk/cli/slash/tui/clipboard.py

@@ -0,0 +1,147 @@
+"""Clipboard adapter for TUI copy actions."""
+
+from __future__ import annotations
+
+import base64
+import os
+import platform
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any
+from collections.abc import Callable
+
+from glaip_sdk.cli.slash.tui.terminal import TerminalCapabilities, detect_osc52_support
+
+
+class ClipboardMethod(str, Enum):
+    """Supported clipboard backends."""
+
+    OSC52 = "osc52"
+    PBCOPY = "pbcopy"
+    XCLIP = "xclip"
+    XSEL = "xsel"
+    WL_COPY = "wl-copy"
+    CLIP = "clip"
+    NONE = "none"
+
+
+@dataclass(frozen=True, slots=True)
+class ClipboardResult:
+    """Result of a clipboard operation."""
+
+    success: bool
+    method: ClipboardMethod
+    message: str
+
+
+_SUBPROCESS_COMMANDS: dict[ClipboardMethod, list[str]] = {
+    ClipboardMethod.PBCOPY: ["pbcopy"],
+    ClipboardMethod.XCLIP: ["xclip", "-selection", "clipboard"],
+    ClipboardMethod.XSEL: ["xsel", "--clipboard", "--input"],
+    ClipboardMethod.WL_COPY: ["wl-copy"],
+    ClipboardMethod.CLIP: ["clip"],
+}
+
+
+class ClipboardAdapter:
+    """Cross-platform clipboard access with OSC 52 fallback."""
+
+    def __init__(
+        self,
+        *,
+        terminal: TerminalCapabilities | None = None,
+        method: ClipboardMethod | None = None,
+    ) -> None:
+        """Initialize the adapter."""
+        self._terminal = terminal
+        self._method = method or self._detect_method()
+
+    @property
+    def method(self) -> ClipboardMethod:
+        """Return the detected clipboard backend."""
+        return self._method
+
+    def copy(self, text: str, *, writer: Callable[[str], Any] | None = None) -> ClipboardResult:
+        """Copy text to clipboard using the best available method.
+
+        Args:
+            text: Text to copy.
+            writer: Optional function to write OSC 52 sequence (e.g., self.app.console.write).
+                   Defaults to sys.stdout.write if not provided.
+        """
+        if self._method == ClipboardMethod.OSC52:
+            return self._copy_osc52(text, writer=writer)
+
+        command = _SUBPROCESS_COMMANDS.get(self._method)
+        if command is None:
+            return self._copy_osc52(text, writer=writer)
+
+        result = self._copy_subprocess(command, text)
+        if not result.success:
+            return self._copy_osc52(text, writer=writer)
+
+        return result
+
+    def _detect_method(self) -> ClipboardMethod:
+        if self._terminal.osc52 if self._terminal else detect_osc52_support():
+            return ClipboardMethod.OSC52
+
+        system = platform.system()
+        if system == "Darwin":
+            return self._detect_darwin_method()
+        if system == "Linux":
+            return self._detect_linux_method()
+        if system == "Windows":
+            return self._detect_windows_method()
+        return ClipboardMethod.NONE
+
+    def _detect_darwin_method(self) -> ClipboardMethod:
+        return ClipboardMethod.PBCOPY if shutil.which("pbcopy") else ClipboardMethod.NONE
+
+    def _detect_linux_method(self) -> ClipboardMethod:
+        if not os.getenv("DISPLAY") and not os.getenv("WAYLAND_DISPLAY"):
+            return ClipboardMethod.NONE
+
+        for cmd, method in (
+            ("xclip", ClipboardMethod.XCLIP),
+            ("xsel", ClipboardMethod.XSEL),
+            ("wl-copy", ClipboardMethod.WL_COPY),
+        ):
+            if shutil.which(cmd):
+                return method
+        return ClipboardMethod.NONE
+
+    def _detect_windows_method(self) -> ClipboardMethod:
+        return ClipboardMethod.CLIP if shutil.which("clip") else ClipboardMethod.NONE
+
+    def _copy_osc52(self, text: str, *, writer: Callable[[str], Any] | None = None) -> ClipboardResult:
+        encoded = base64.b64encode(text.encode("utf-8")).decode("ascii")
+        sequence = f"\x1b]52;c;{encoded}\x07"
+        try:
+            if writer:
+                writer(sequence)
+            else:
+                sys.stdout.write(sequence)
+                sys.stdout.flush()
+        except Exception as exc:
+            return ClipboardResult(False, ClipboardMethod.OSC52, str(exc))
+
+        return ClipboardResult(True, ClipboardMethod.OSC52, "Copied to clipboard")
+
+    def _copy_subprocess(self, cmd: list[str], text: str) -> ClipboardResult:
+        try:
+            completed = subprocess.run(
+                cmd,
+                input=text.encode("utf-8"),
+                check=False,
+            )
+        except OSError as exc:
+            return ClipboardResult(False, self._method, str(exc))
+
+        if completed.returncode == 0:
+            return ClipboardResult(True, self._method, "Copied to clipboard")
+
+        return ClipboardResult(False, self._method, f"Command failed: {completed.returncode}")

glaip_sdk/cli/slash/tui/context.py

@@ -10,9 +10,15 @@ Authors:
 
 from __future__ import annotations
 
+import os
 from dataclasses import dataclass
+from typing import TYPE_CHECKING
 
 from glaip_sdk.cli.slash.tui.terminal import TerminalCapabilities
+from glaip_sdk.cli.slash.tui.theme import ThemeManager
+
+if TYPE_CHECKING:
+    from glaip_sdk.cli.slash.tui.toast import ToastBus
 
 
 @dataclass
@@ -32,8 +38,8 @@ class TUIContext:
 
     terminal: TerminalCapabilities
     keybinds: object | None = None
-    theme: object | None = None
-    toasts: object | None = None
+    theme: ThemeManager | None = None
+    toasts: ToastBus | None = None
     clipboard: object | None = None
 
     @classmethod
@@ -48,4 +54,6 @@ class TUIContext:
             TUIContext instance with terminal capabilities detected.
         """
         terminal = await TerminalCapabilities.detect()
-        return cls(terminal=terminal)
+        theme_name = os.getenv("AIP_TUI_THEME") or None
+        theme = ThemeManager(terminal, theme=theme_name)
+        return cls(terminal=terminal, theme=theme)

glaip_sdk/cli/slash/tui/keybind_registry.py

@@ -0,0 +1,235 @@
+"""Keybinding registry helpers for TUI applications."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from dataclasses import dataclass
+
+DEFAULT_LEADER = "ctrl+x"
+_LEADER_TOKEN = "<leader>"
+
+_MODIFIER_ORDER = ("ctrl", "alt", "shift", "meta")
+_MODIFIER_SYNONYMS = {
+    "control": "ctrl",
+    "ctl": "ctrl",
+    "cmd": "meta",
+    "command": "meta",
+    "option": "alt",
+    "return": "enter",
+}
+
+_KEY_SYNONYMS = {
+    "esc": "escape",
+}
+
+_KEY_DISPLAY = {
+    "escape": "Esc",
+    "enter": "Enter",
+    "space": "Space",
+    "tab": "Tab",
+    "backspace": "Backspace",
+}
+
+
+@dataclass(frozen=True, slots=True)
+class Keybind:
+    """A registered keybinding."""
+
+    action: str
+    sequence: tuple[str, ...]
+    description: str
+    category: str | None = None
+
+    def __repr__(self) -> str:
+        """Return a readable representation of the keybind."""
+        return (
+            f"Keybind(action={self.action!r}, sequence={self.sequence}, "
+            f"description={self.description!r}, category={self.category!r})"
+        )
+
+
+class KeybindRegistry:
+    """Central registry of keybindings and associated metadata."""
+
+    def __init__(self, *, leader: str = DEFAULT_LEADER) -> None:
+        """Initialize the registry."""
+        normalized = _normalize_chord(leader)
+        self._leader = normalized or DEFAULT_LEADER
+        self._keybinds: dict[str, Keybind] = {}
+
+    @property
+    def leader(self) -> str:
+        """Return the normalized leader chord."""
+        return self._leader
+
+    def register(
+        self,
+        *,
+        action: str,
+        key: str,
+        description: str,
+        category: str | None = None,
+    ) -> Keybind:
+        """Register a keybinding for an action."""
+        if action in self._keybinds:
+            raise ValueError(f"Action already registered: {action}")
+
+        sequence = parse_key_sequence(key)
+        keybind = Keybind(action=action, sequence=sequence, description=description, category=category)
+        self._keybinds[action] = keybind
+        return keybind
+
+    def get(self, action: str) -> Keybind | None:
+        """Return keybind for action, if present."""
+        return self._keybinds.get(action)
+
+    def actions(self) -> list[str]:
+        """Return sorted list of registered actions."""
+        return sorted(self._keybinds)
+
+    def matches(self, action: str, sequence: str | Iterable[str]) -> bool:
+        """Return True if the provided sequence matches the action's keybind."""
+        keybind = self._keybinds.get(action)
+        if keybind is None:
+            return False
+
+        candidate = _coerce_sequence(sequence)
+        return candidate == keybind.sequence
+
+    def format(self, action: str) -> str:
+        """Return a human-readable sequence for an action."""
+        keybind = self._keybinds.get(action)
+        if keybind is None:
+            return ""
+
+        return format_key_sequence(keybind.sequence, leader=self._leader)
+
+
+def parse_key_sequence(key: str) -> tuple[str, ...]:
+    """Parse a key sequence string into normalized tokens."""
+    tokens = [token for token in key.strip().split() if token]
+    normalized: list[str] = []
+
+    for token in tokens:
+        if token.lower() == _LEADER_TOKEN:
+            normalized.append(_LEADER_TOKEN)
+            continue
+
+        chord = _normalize_chord(token)
+        if chord:
+            normalized.append(chord)
+
+    return tuple(normalized)
+
+
+def format_key_sequence(sequence: tuple[str, ...], *, leader: str = DEFAULT_LEADER) -> str:
+    """Format a normalized sequence into a display string."""
+    rendered: list[str] = []
+
+    for token in sequence:
+        if token == _LEADER_TOKEN:
+            rendered.append(_format_token(leader))
+            continue
+        rendered.append(_format_token(token))
+
+    return " ".join(rendered)
+
+
+def _coerce_sequence(sequence: str | Iterable[str]) -> tuple[str, ...]:
+    if isinstance(sequence, str):
+        return parse_key_sequence(sequence)
+
+    tokens: list[str] = []
+    for token in sequence:
+        if not token:
+            continue
+        if token.lower() == _LEADER_TOKEN:
+            tokens.append(_LEADER_TOKEN)
+            continue
+        chord = _normalize_chord(token)
+        if chord:
+            tokens.append(chord)
+
+    return tuple(tokens)
+
+
+def _normalize_chord(chord: str) -> str:
+    """Normalize a key chord string to canonical form.
+
+    Normalization rules:
+    - Converts separators: both '-' and '+' are normalized to '+'
+    - Handles synonyms: 'control'/'ctl' -> 'ctrl', 'cmd'/'command' -> 'meta', 'option' -> 'alt'
+    - Deduplicates modifiers: 'ctrl+ctrl+l' -> 'ctrl+l'
+    - Orders modifiers: ctrl < alt < shift < meta (unknown modifiers sort last)
+    - Case-insensitive: 'Ctrl+L' == 'ctrl+l' == 'CTRL-L'
+
+    Args:
+        chord: Key chord string (e.g., "Ctrl+L", "ctrl-l", "CTRL+CTRL+L")
+
+    Returns:
+        Normalized chord string (e.g., "ctrl+l") or empty string if invalid.
+    """
+    parts = [part for part in chord.replace("-", "+").split("+") if part.strip()]
+    if not parts:
+        return ""
+
+    normalized_parts = [_normalize_key_part(part) for part in parts]
+    if len(normalized_parts) == 1:
+        return normalized_parts[0]
+
+    modifiers, key = normalized_parts[:-1], normalized_parts[-1]
+
+    seen: set[str] = set()
+    unique_mods: list[str] = []
+    for mod in modifiers:
+        if mod in seen:
+            continue
+        seen.add(mod)
+        unique_mods.append(mod)
+
+    unique_mods.sort(key=_modifier_sort_key)
+    return "+".join([*unique_mods, key])
+
+
+def _normalize_key_part(part: str) -> str:
+    token = part.strip().lower()
+    token = _MODIFIER_SYNONYMS.get(token, token)
+    return _KEY_SYNONYMS.get(token, token)
+
+
+def _modifier_sort_key(modifier: str) -> int:
+    try:
+        return _MODIFIER_ORDER.index(modifier)
+    except ValueError:
+        return len(_MODIFIER_ORDER)
+
+
+def _format_token(token: str) -> str:
+    if "+" in token:
+        return _format_chord(token)
+
+    return _KEY_DISPLAY.get(token, token)
+
+
+def _format_chord(chord: str) -> str:
+    parts = chord.split("+")
+    modifiers, key = parts[:-1], parts[-1]
+
+    rendered_mods: list[str] = []
+    for mod in modifiers:
+        if mod == "ctrl":
+            rendered_mods.append("Ctrl")
+        elif mod == "alt":
+            rendered_mods.append("Alt")
+        elif mod == "shift":
+            rendered_mods.append("Shift")
+        elif mod == "meta":
+            rendered_mods.append("Meta")
+        else:
+            rendered_mods.append(mod.title())
+
+    rendered_key = _KEY_DISPLAY.get(key, key)
+    if len(rendered_key) == 1 and rendered_key.isalpha():
+        rendered_key = rendered_key.upper()
+
+    return "+".join([*rendered_mods, rendered_key])