ezshell 0.2.0__py3-none-any.whl

src/ui/inline.py

@@ -0,0 +1,330 @@
+"""Flux inline : `ezsh suggest`.
+
+L'interface s'affiche sur le terminal (/dev/tty sous Unix, la console CONOUT$/CONIN$ sous
+Windows) ; seule la commande finale sort sur stdout, que la fonction shell récupère.
+
+Règles (DEVELOPMENT.md §1) : jamais d'exécution silencieuse (on n'exécute RIEN, on insère
+dans le prompt via la fonction shell), le contenu des requêtes n'est jamais journalisé.
+Deux modes de touches : *résultat* (⏎ c e / q Esc y) et *saisie* (⏎ envoie, Esc revient).
+"""
+
+from __future__ import annotations
+
+import os
+import select
+import shutil
+import subprocess
+import sys
+from contextlib import contextmanager
+from typing import Optional, TextIO, Tuple
+
+from src.core.provider import (
+    LLMProvider,
+    MissingKey,
+    ProviderError,
+    ProviderOffline,
+    QuotaExceeded,
+    UpdateRequired,
+    get_provider,
+)
+from src.core.schema import InvalidResponse
+from src.core.suggest import Suggestion, build_request, detect_lang, get_suggestion
+from src.ui.panel import loading_text, message_panel, result_panel, tr
+
+IS_WINDOWS = os.name == "nt"
+WIN_CONSOLE = -2  # pseudo-descripteur : les touches se lisent via msvcrt, pas via un fd
+
+if IS_WINDOWS:  # pragma: no cover - exécuté sur la CI Windows
+    import msvcrt
+
+    termios = None  # type: ignore
+else:
+    import termios
+    import tty as _tty
+
+
+def _enable_vt(stream: TextIO) -> None:
+    """Active les séquences ANSI sur la console Windows (effacement de ligne, couleurs)."""
+    try:  # pragma: no cover - Windows uniquement
+        import ctypes
+
+        kernel32 = ctypes.windll.kernel32  # type: ignore[attr-defined]
+        handle = msvcrt.get_osfhandle(stream.fileno())
+        mode = ctypes.c_uint32()
+        if kernel32.GetConsoleMode(handle, ctypes.byref(mode)):
+            # ENABLE_VIRTUAL_TERMINAL_PROCESSING
+            kernel32.SetConsoleMode(handle, mode.value | 0x0004)
+    except Exception:
+        pass
+
+
+def open_tty() -> Tuple[Optional[TextIO], Optional[int]]:
+    """(flux d'écriture, lecteur de touches) sur le terminal, même si stdout est capturé."""
+    if IS_WINDOWS:  # pragma: no cover - Windows uniquement
+        try:
+            out = open("CONOUT$", "w", buffering=1, encoding="utf-8", errors="replace")
+        except OSError:
+            return None, None
+        _enable_vt(out)
+        return out, WIN_CONSOLE
+    try:
+        fd = os.open("/dev/tty", os.O_RDWR)
+        return os.fdopen(os.dup(fd), "w", buffering=1, encoding="utf-8"), fd
+    except OSError:
+        return None, None
+
+
+@contextmanager
+def raw_mode(fd: int):
+    if fd == WIN_CONSOLE:  # msvcrt lit déjà touche par touche, sans écho
+        yield
+        return
+    old = termios.tcgetattr(fd)
+    try:
+        _tty.setcbreak(fd)
+        yield
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old)
+
+
+# Touches étendues de la console Windows (préfixe \x00 ou \xe0)
+_WIN_SPECIAL = {"K": "left", "M": "right", "G": "home", "O": "end", "S": "ignore"}
+
+
+def _read_key_windows() -> str:  # pragma: no cover - Windows uniquement
+    ch = msvcrt.getwch()
+    if ch in ("\x00", "\xe0"):
+        return _WIN_SPECIAL.get(msvcrt.getwch(), "ignore")
+    return {"\r": "enter", "\n": "enter", "\x03": "ctrl-c", "\x08": "backspace", "\x1b": "esc"}.get(
+        ch, ch
+    )
+
+
+def read_key(fd: int) -> str:
+    """Une touche : enter, esc, backspace, left, right, home, end, ctrl-c, ou le caractère."""
+    if fd == WIN_CONSOLE:
+        return _read_key_windows()
+    b = os.read(fd, 1)
+    if not b:
+        return "esc"
+    ch = b.decode("utf-8", errors="ignore")
+    if ch in ("\r", "\n"):
+        return "enter"
+    if ch == "\x03":
+        return "ctrl-c"
+    if ch in ("\x7f", "\x08"):
+        return "backspace"
+    if ch == "\x1b":
+        if not select.select([fd], [], [], 0.05)[0]:
+            return "esc"
+        seq = os.read(fd, 8).decode("utf-8", errors="ignore")
+        return {
+            "[D": "left",
+            "[C": "right",
+            "[H": "home",
+            "[F": "end",
+            "[1~": "home",
+            "[4~": "end",
+        }.get(seq, "ignore")
+    if ch and ord(ch[0]) >= 0x80:  # début d'un caractère UTF-8 multi-octets
+        need = 1 if b[0] >> 5 == 0b110 else 2 if b[0] >> 4 == 0b1110 else 3
+        ch = (b + os.read(fd, need)).decode("utf-8", errors="ignore")
+    return ch
+
+
+def edit_line(fd: int, out: TextIO, prompt: str, initial: str = "") -> Optional[str]:
+    """Mini éditeur de ligne (stdout reste libre). Retourne None si Échap."""
+    buf, pos = list(initial), len(initial)
+
+    def redraw() -> None:
+        out.write("\r\x1b[2K" + prompt + "".join(buf))
+        out.write("\r" + "\x1b[%dC" % (len(prompt) + pos) if len(prompt) + pos else "\r")
+        out.flush()
+
+    redraw()
+    with raw_mode(fd):
+        while True:
+            k = read_key(fd)
+            if k == "enter":
+                out.write("\n")
+                return "".join(buf).strip()
+            if k in ("esc", "ctrl-c"):
+                out.write("\n")
+                return None
+            if k == "backspace" and pos:
+                del buf[pos - 1]
+                pos -= 1
+            elif k == "left":
+                pos = max(0, pos - 1)
+            elif k == "right":
+                pos = min(len(buf), pos + 1)
+            elif k == "home":
+                pos = 0
+            elif k == "end":
+                pos = len(buf)
+            elif len(k) >= 1 and k not in ("ignore", "backspace") and k.isprintable():
+                buf.insert(pos, k)
+                pos += 1
+            redraw()
+
+
+def copy_to_clipboard(text: str) -> bool:
+    if IS_WINDOWS:  # clip.exe lit l'UTF-16 avec BOM : accents et symboles conservés
+        try:
+            data = b"\xff\xfe" + text.encode("utf-16-le")
+            subprocess.run(["clip"], input=data, check=True, timeout=2)
+            return True
+        except Exception:
+            return False
+    for cmd in (
+        ["pbcopy"],
+        ["wl-copy"],
+        ["xclip", "-selection", "clipboard"],
+        ["xsel", "--clipboard", "--input"],
+    ):
+        if shutil.which(cmd[0]):
+            try:
+                subprocess.run(cmd, input=text.encode(), check=True, timeout=2)
+                return True
+            except Exception:
+                continue
+    return False
+
+
+def _fetch(req, provider: LLMProvider, console, lang: str):
+    """Retourne ('ok', Suggestion) ou (kind, kwargs) pour message_panel."""
+    try:
+        with console.status(loading_text(lang), spinner="dots"):
+            return "ok", get_suggestion(req, provider)
+    except ProviderOffline:
+        return "offline", {}
+    except QuotaExceeded as q:
+        return ("trial" if q.scope == "anonymous" else "quota"), {
+            "scope": q.scope,
+            "reset": q.reset_at,
+        }
+    except UpdateRequired:
+        return "update_required", {}
+    except MissingKey:
+        return "nokey", {}
+    except InvalidResponse:
+        return "invalid", {}
+    except ProviderError:
+        return "error", {}
+
+
+def run_inline(ask: Optional[str] = None, provider: Optional[LLMProvider] = None) -> int:
+    """0 : commande écrite sur stdout ; 1 : annulé ; 2 : environnement inadapté (pas de tty)."""
+    out, fd = open_tty()
+    if out is None or fd is None:
+        print("ezsh: terminal interactif requis (pas de /dev/tty ni de console).", file=sys.stderr)
+        return 2
+    # PSReadLine redessine le prompt à sa position d'origine : le hook PowerShell demande
+    # l'écran alternatif pour que le panneau ne décale pas la ligne de saisie.
+    alt = os.environ.get("EZSH_ALT_SCREEN") == "1"
+    if alt:
+        out.write("\x1b[?1049h\x1b[H")
+        out.flush()
+    try:
+        return _run_inline(out, fd, ask, provider)
+    finally:
+        if alt:
+            out.write("\x1b[?1049l")
+            out.flush()
+
+
+def _run_inline(out: TextIO, fd: int, ask: Optional[str], provider: Optional[LLMProvider]) -> int:
+    from rich.console import Console
+    lang = detect_lang()
+    t = tr(lang)
+    width = min(80, shutil.get_terminal_size((80, 24)).columns)
+    console = Console(
+        file=out,
+        force_terminal=True,
+        legacy_windows=False,  # VT activé sur la console Windows : rendu ANSI partout
+        width=width,
+        highlight=False,
+        markup=False,
+        emoji=False,
+    )
+    provider = provider or get_provider()
+
+    query = (ask or "").strip()
+    last_state: Tuple[str, object] = ("empty", {})
+
+    def ask_model(q: str) -> Tuple[str, object]:
+        return _fetch(build_request(q), provider, console, lang)
+
+    # ouverture : question explicite, sinon dernière commande, sinon panneau vide
+    from src.core.capture import read_last_run
+
+    if query or read_last_run():
+        last_state = ask_model(query)
+    show(console, last_state, lang)
+    _update_notice(console)
+
+    while True:
+        kind, payload = last_state
+        with raw_mode(fd):
+            key = read_key(fd)
+        if key in ("q", "esc", "ctrl-c"):
+            return 1
+        if key == "/":
+            q = edit_line(fd, out, f"{t['ask']} › ")
+            if q:
+                last_state = ask_model(q)
+                show(console, last_state, lang)
+            continue
+        if kind != "ok":
+            continue
+        s: Suggestion = payload  # type: ignore[assignment]
+        if not s.command:
+            continue
+        if key == "c":
+            console.print(t["copied"] if copy_to_clipboard(s.command) else t["nocopy"], style="dim")
+        elif key == "e":
+            console.print(t["edit"], style="dim")
+            edited = edit_line(
+                fd, out, "$ ", s.command.replace("\n", " ; ") if s.multiline else s.command
+            )
+            if edited:
+                return _emit(edited, console, t)
+        elif key == "enter" and s.risk != "high" and not s.multiline:
+            return _emit(s.command, console, t)
+        elif key == "y" and (s.risk == "high" or s.multiline):
+            return _emit(s.command, console, t)
+
+
+def _update_notice(console) -> None:
+    """Une ligne discrète, au plus une fois par jour, si une nouvelle version existe."""
+    try:
+        from src.core.updater import take_notice
+
+        line = take_notice()
+        if line:
+            console.print(line, style="dim")
+    except Exception:  # le rappel ne doit jamais gêner le panneau
+        pass
+
+
+def show(console, state: Tuple[str, object], lang: str) -> None:
+    kind, payload = state
+    console.print(
+        result_panel(payload, lang)
+        if kind == "ok"
+        else message_panel(kind, lang, **(payload or {}))
+    )  # type: ignore[arg-type]
+
+
+def _emit(command: str, console, t: dict) -> int:
+    from src.core.sanitize import sanitize_command
+
+    safe = sanitize_command(command)
+    if safe.multiline:  # garde-fou final : jamais de saut de ligne dans le prompt
+        safe_text = " ; ".join(line.strip() for line in safe.text.splitlines() if line.strip())
+    else:
+        safe_text = safe.text
+    console.print(t["inserted"], style="dim")
+    sys.stdout.write(safe_text)
+    sys.stdout.flush()
+    return 0

src/ui/logo.py

@@ -0,0 +1,194 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import List
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+INSTALL_MARKER_PATH = Path.home() / ".ezshell" / ".installed"
+
+
+def is_first_install() -> bool:
+    """Checks if ezShell is being run for the first time by the user."""
+    return not INSTALL_MARKER_PATH.exists()
+
+
+def mark_as_installed() -> None:
+    """Creates the marker file indicating ezShell has been installed and welcomed."""
+    try:
+        INSTALL_MARKER_PATH.parent.mkdir(parents=True, exist_ok=True)
+        INSTALL_MARKER_PATH.touch(exist_ok=True)
+    except Exception:
+        pass
+
+
+def _gradient(text: str, r1: int, g1: int, b1: int, r2: int, g2: int, b2: int) -> str:
+    """Applies a horizontal truecolor gradient across a string of characters."""
+    n = max(len(text) - 1, 1)
+    result = ""
+    for i, ch in enumerate(text):
+        t = i / n
+        r = int(r1 + (r2 - r1) * t)
+        g = int(g1 + (g2 - g1) * t)
+        b = int(b1 + (b2 - b1) * t)
+        result += f"\033[38;2;{r};{g};{b}m{ch}"
+    return result + "\033[0m"
+
+
+def _vertical_gradient_lines(
+    lines: List[str],
+    r1: int, g1: int, b1: int,
+    r2: int, g2: int, b2: int,
+) -> List[str]:
+    """Applies a vertical truecolor gradient across multiple lines."""
+    n = max(len(lines) - 1, 1)
+    result = []
+    for i, line in enumerate(lines):
+        t = i / n
+        r = int(r1 + (r2 - r1) * t)
+        g = int(g1 + (g2 - g1) * t)
+        b = int(b1 + (b2 - b1) * t)
+        result.append(f"\033[38;2;{r};{g};{b}m{line}\033[0m")
+    return result
+
+
+def render_logo_ascii() -> List[str]:
+    """Renders the official ezShell logo as high-quality hand-crafted ASCII art.
+
+    The logo is the iconic "C>" terminal prompt shape: a rounded bracket "C"
+    with a chevron ">" and cursor bar "=" inside. Uses ANSI truecolor for a
+    cyan-to-blue vertical gradient that mimics the metallic 3D look.
+    """
+    # Raw ASCII art lines (no color) -- hand-crafted to match the symbol logo shape
+    raw = [
+        r"            ██████████████████████████            ",
+        r"        ████▀▀                      ▀▀████        ",
+        r"      ███▀    ████████████████████████    ▀███      ",
+        r"    ███▀    ███▀                    ▀███    ▀███    ",
+        r"   ███    ███▀                        ▀███    ███   ",
+        r"  ███    ███                            ███    ███  ",
+        r"  ███   ███      ██▄                    ███   ███  ",
+        r"  ███   ███       ████▄                 ███   ███  ",
+        r"  ███   ███        █████▄    ████████   ███   ███  ",
+        r"  ███   ███       ████▀                 ███   ███  ",
+        r"  ███   ███      ██▀                    ███   ███  ",
+        r"  ███    ███                            ███    ███  ",
+        r"   ███    ███▄                        ▄███    ███   ",
+        r"    ███▄    ███▄                    ▄███    ▄███    ",
+        r"      ███▄    ████████████████████████    ▄███      ",
+        r"        ████▄▄                      ▄▄████        ",
+        r"            ██████████████████████████            ",
+    ]
+
+    # Apply a vertical gradient: bright cyan (#00E5FF) -> deep blue (#0066FF)
+    return _vertical_gradient_lines(
+        raw,
+        r1=0, g1=229, b1=255,    # top: Electric Cyan
+        r2=0, g2=102, b2=255,    # bottom: Deep Blue
+    )
+
+
+def render_logo_compact() -> str:
+    """Returns a compact single-line colored logo mark for prompts and headers."""
+    c = "\033[1;38;2;0;229;255m"   # Bold Electric Cyan
+    b = "\033[1;38;2;0;136;255m"   # Bold Deep Blue
+    r = "\033[0m"
+    return f"{c}[{b}>{c}_{b}]{r}"
+
+
+def render_logo_mini() -> List[str]:
+    """Returns a smaller 9-line logo variant for tighter terminal widths."""
+    raw = [
+        r"      ▄▄████████████████▄▄      ",
+        r"    ██▀  ██████████████  ▀██    ",
+        r"  ██▀  ██▀            ▀██  ▀██  ",
+        r"  ██  ██    ██▄          ██  ██  ",
+        r"  ██  ██     ████  ████  ██  ██  ",
+        r"  ██  ██    ██▀          ██  ██  ",
+        r"  ██▄  ██▄            ▄██  ▄██  ",
+        r"    ██▄  ██████████████  ▄██    ",
+        r"      ▀▀████████████████▀▀      ",
+    ]
+    return _vertical_gradient_lines(
+        raw,
+        r1=0, g1=229, b1=255,
+        r2=0, g2=102, b2=255,
+    )
+
+
+def render_title_text() -> str:
+    """Returns the 'ezShell' title as a gradient text string."""
+    return _gradient(
+        "  e z S h e l l",
+        r1=0, g1=229, b1=255,
+        r2=0, g2=255, b2=136,
+    )
+
+
+def show_welcome_banner(force: bool = False) -> None:
+    """Displays the welcome screen with the official ASCII logo on first installation.
+
+    Shows a side-by-side layout: the hand-crafted ASCII art logo on the left
+    and a rich info card with usage instructions on the right.
+
+    The card content is automatically rendered in the user's detected language
+    (French or English) via the ``src.i18n`` module.
+
+    Args:
+        force: If ``True``, display the banner regardless of whether it has been
+               shown before (useful for ``ezsh --logo``). Defaults to ``False``.
+    """
+    if not force and not is_first_install():
+        return
+
+    # Lazy import to avoid circular imports at module load time
+    from src.i18n import t  # noqa: PLC0415
+
+    console = Console()
+    console.print()
+
+    # Choose logo size based on terminal width
+    term_width = console.width or 80
+    if term_width >= 90:
+        logo_lines = render_logo_ascii()
+    else:
+        logo_lines = render_logo_mini()
+
+    logo_block = "\n".join(logo_lines)
+
+    # Build bilingual info card using i18n strings
+    info_card = f"""[bold #00E5FF]{t("welcome_title")}[/bold #00E5FF]
+[dim #94A3B8]{t("welcome_subtitle")}[/dim #94A3B8]
+
+[bold #FFFFFF]{t("welcome_body")}[/bold #FFFFFF]
+
+[bold #00FF88]{t("welcome_how_to_use")}[/bold #00FF88]
+  [bold #00E5FF]ezsh[/bold #00E5FF]               {t("welcome_cmd_desktop")}
+  [bold #00E5FF]ezsh --tui[/bold #00E5FF]         {t("welcome_cmd_tui")}
+  [bold #00E5FF]ezsh --set-key[/bold #00E5FF]     {t("welcome_cmd_setkey")}
+  [bold #00E5FF]ezsh -c <cmd>[/bold #00E5FF]      {t("welcome_cmd_single")}
+  [bold #00E5FF]ezsh --help[/bold #00E5FF]        {t("welcome_cmd_help")}
+
+[italic #94A3B8]{t("welcome_footer")}[/italic #94A3B8]
+"""
+
+    grid = Table.grid(padding=(0, 3))
+    grid.add_column(justify="center", vertical="middle")
+    grid.add_column(vertical="middle")
+
+    grid.add_row(
+        Text.from_ansi(logo_block),
+        Panel(
+            info_card.strip(),
+            border_style="#00E5FF",
+            padding=(1, 2),
+        ),
+    )
+
+    console.print(grid)
+    console.print()
+    mark_as_installed()
+

src/ui/panel.py

@@ -0,0 +1,163 @@
+"""Panneau inline Rich (DEVELOPMENT.md §7.5) : un rendu par état, 80 colonnes max.
+
+Le risque est TOUJOURS indiqué par un libellé texte (jamais par la seule couleur).
+Tout le texte venant du modèle est déjà nettoyé (schema.py / sanitize.py) ; on désactive
+en plus le markup Rich pour qu'un texte du modèle ne puisse pas styler l'écran.
+"""
+
+from __future__ import annotations
+
+from typing import List
+
+from rich.console import Group
+from rich.panel import Panel
+from rich.text import Text
+
+MAX_WIDTH = 80
+
+T = {
+    "fr": {
+        "title": "ezShell",
+        "cause": "Cause",
+        "assume": "Hypothèses",
+        "conf": "Confiance",
+        "risk": {"low": "RISQUE FAIBLE", "medium": "RISQUE MOYEN", "high": "RISQUE ÉLEVÉ"},
+        "confv": {"low": "faible", "medium": "moyenne", "high": "élevée"},
+        "keys": "⏎ insérer · c copier · e éditer · / question · q quitter",
+        "keys_high": "y insérer quand même · c copier · e éditer · / question · q quitter",
+        "keys_multi": "y insérer (multiligne) · c copier · / question · q quitter",
+        "keys_none": "/ poser une question · q quitter",
+        "loading": "Analyse en cours…",
+        "floor": "Risque relevé par les règles de sécurité d'ezShell.",
+        "nooutput": "Sortie d'erreur non capturée : lance `ezsh run -- <commande>` pour de meilleurs diagnostics.",
+        "uncertain": "Réponse incertaine : vérifie avant d'agir.",
+        "multi": "Commande sur plusieurs lignes : rien ne sera exécuté à l'insertion.",
+        "nolast": "Aucune commande récente. Pose une question en langage naturel.",
+        "offline": "Hors ligne : impossible de joindre le service. Le terminal n'est pas bloqué.",
+        "quota": "Limite atteinte ({scope}). Réinitialisation : {reset}.",
+        "trial": "Limite d'essai atteinte. Crée un compte gratuit pour continuer (`ezsh login`, bientôt).",
+        "update_required": "Cette version d'ezShell n'est plus prise en charge. Lance `ezsh --update`.",
+        "pending": "Connexion en attente : valide le code {code} sur {url}.",
+        "error": "Le service est indisponible pour le moment. Réessaie dans un instant.",
+        "invalid": "Réponse du modèle illisible : rien n'est affiché ni inséré.",
+        "nokey": "Aucune clé configurée. `ezsh --set-key <clé>` ou EZSH_MOCK_LLM=1 pour tester sans réseau.",
+        "ask": "Ta question",
+        "edit": "Édite puis ⏎ (Échap : annuler)",
+        "copied": "Copié dans le presse-papiers.",
+        "nocopy": "Aucun outil de presse-papiers trouvé.",
+        "inserted": "Commande insérée : relis-la puis appuie sur Entrée.",
+    },
+    "en": {
+        "title": "ezShell",
+        "cause": "Cause",
+        "assume": "Assumptions",
+        "conf": "Confidence",
+        "risk": {"low": "LOW RISK", "medium": "MEDIUM RISK", "high": "HIGH RISK"},
+        "confv": {"low": "low", "medium": "medium", "high": "high"},
+        "keys": "⏎ insert · c copy · e edit · / ask · q quit",
+        "keys_high": "y insert anyway · c copy · e edit · / ask · q quit",
+        "keys_multi": "y insert (multi-line) · c copy · / ask · q quit",
+        "keys_none": "/ ask a question · q quit",
+        "loading": "Analyzing…",
+        "floor": "Risk raised by ezShell's safety rules.",
+        "nooutput": "Error output not captured: run `ezsh run -- <command>` for better diagnostics.",
+        "uncertain": "Uncertain answer: double-check before acting.",
+        "multi": "Multi-line command: nothing is executed on insertion.",
+        "nolast": "No recent command. Ask a question in plain language.",
+        "offline": "Offline: the service is unreachable. Your terminal is not blocked.",
+        "quota": "Limit reached ({scope}). Resets: {reset}.",
+        "trial": "Trial limit reached. Create a free account to continue (`ezsh login`, coming soon).",
+        "update_required": "This ezShell version is no longer supported. Run `ezsh --update`.",
+        "pending": "Login pending: confirm code {code} at {url}.",
+        "error": "The service is unavailable right now. Try again shortly.",
+        "invalid": "Unreadable model answer: nothing is shown or inserted.",
+        "nokey": "No key configured. `ezsh --set-key <key>` or EZSH_MOCK_LLM=1 to try offline.",
+        "ask": "Your question",
+        "edit": "Edit then ⏎ (Esc: cancel)",
+        "copied": "Copied to clipboard.",
+        "nocopy": "No clipboard tool found.",
+        "inserted": "Command inserted: review it, then press Enter.",
+    },
+}
+
+_RISK_STYLE = {"low": "bold green", "medium": "bold yellow", "high": "bold white on red"}
+_BORDER = {"low": "green", "medium": "yellow", "high": "red"}
+
+
+def tr(lang: str) -> dict:
+    return T.get(lang, T["en"])
+
+
+def _wrap(body: List, title: str, border: str, footer: str) -> Panel:
+    return Panel(
+        Group(*body),
+        title=title,
+        title_align="left",
+        subtitle=footer,
+        subtitle_align="left",
+        border_style=border,
+        width=None,
+        padding=(0, 1),
+    )
+
+
+def result_panel(s, lang: str) -> Panel:
+    """`s` : suggest.Suggestion."""
+    t = tr(lang)
+    body: List = []
+    if s.command:
+        cmd = Text("$ ", style="bold cyan")
+        cmd.append(s.command, style="bold")
+        body.append(cmd)
+    label = Text(f" {t['risk'][s.risk]} ", style=_RISK_STYLE[s.risk])
+    if s.risk_reason:
+        label.append(f"  {s.risk_reason}", style="default")
+    body.append(label)
+    if s.risk_floor_applied:
+        body.append(Text(t["floor"], style="dim italic"))
+    if s.response.explanation:
+        body.append(Text(s.response.explanation))
+    if s.response.cause:
+        body.append(Text(f"{t['cause']} : {s.response.cause}", style="dim"))
+    uncertain = s.response.confidence == "low" or not s.command
+    if uncertain:
+        body.append(Text(f"⚠ {t['uncertain']}", style="yellow"))
+    if s.response.assumptions:
+        body.append(Text(f"{t['assume']} : " + " · ".join(s.response.assumptions), style="dim"))
+    body.append(Text(f"{t['conf']} : {t['confv'][s.response.confidence]}", style="dim"))
+    if s.multiline:
+        body.append(Text(f"⚠ {t['multi']}", style="yellow"))
+    if s.no_output_captured:
+        body.append(Text(f"ℹ {t['nooutput']}", style="dim"))
+    if not s.command:
+        footer = t["keys_none"]
+    elif s.multiline:
+        footer = t["keys_multi"]
+    elif s.risk == "high":
+        footer = t["keys_high"]
+    else:
+        footer = t["keys"]
+    return _wrap(body, t["title"], _BORDER[s.risk], footer)
+
+
+def message_panel(kind: str, lang: str, **kw) -> Panel:
+    """États sans résultat : empty, offline, quota, trial, pending, error, invalid, nokey, update_required."""
+    t = tr(lang)
+    text = {
+        "empty": t["nolast"],
+        "offline": t["offline"],
+        "trial": t["trial"],
+        "error": t["error"],
+        "invalid": t["invalid"],
+        "nokey": t["nokey"],
+        "update_required": t["update_required"],
+        "quota": t["quota"].format(scope=kw.get("scope", "?"), reset=kw.get("reset") or "?"),
+        "pending": t["pending"].format(code=kw.get("code", "????"), url=kw.get("url", "")),
+    }[kind]
+    border = "cyan" if kind in ("empty", "pending") else "yellow"
+    footer = t["keys_none"] if kind in ("empty", "offline", "error", "invalid", "nokey", "update_required") else "q"
+    return _wrap([Text(text)], t["title"], border, footer)
+
+
+def loading_text(lang: str) -> str:
+    return tr(lang)["loading"]