lyra-assistant 1.3.1__py3-none-any.whl

lyra/__init__.py

@@ -0,0 +1,11 @@
+"""
+Lyra RAG - Architecture hybride avec dual models et RAG.
+
+Modules:
+- rag: Systeme de retrieval hybride (ChromaDB + BM25 + RRF)
+- models: Dual models EPHAISTOS (Qwen 7B) + LYRA (Llama 3B)
+- hestia: Executeur MCP avec logging optionnel
+- core: Pipeline et configuration
+"""
+
+__version__ = "2.0.0"

lyra/client/__init__.py

@@ -0,0 +1 @@
+"""Lyra Client - clients legers du demon (CLI one-shot, REPL, vocal)."""

lyra/client/__main__.py

@@ -0,0 +1,183 @@
+"""
+Lyra Client - Point d'entree CLI.
+
+Route les invocations :
+- one-shot texte  -> demon (relance auto si mort) puis fallback standalone
+- interactif / vocal / legacy / --standalone -> main_rag historique (Phase 4
+  du chantier demon : le REPL deviendra client a son tour)
+
+Codes de sortie identiques a run_one_shot : 0=ok, 1=erreur, 2=annule, 3=args.
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib.metadata
+import os
+import sys
+import tomllib
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent.parent
+PACKAGE_NAME = "lyra-assistant"
+
+
+def _package_version() -> str:
+    """Version installee du paquet ; depuis les sources, lue dans pyproject.toml."""
+    try:
+        return importlib.metadata.version(PACKAGE_NAME)
+    except importlib.metadata.PackageNotFoundError:
+        pass
+    try:
+        with open(REPO_ROOT / "pyproject.toml", "rb") as f:
+            version = tomllib.load(f)["project"]["version"]
+    except (OSError, tomllib.TOMLDecodeError, KeyError):
+        version = "unknown"
+    return f"{version} (sources)"
+
+
+def _print_incomplete_integrations_reminder() -> None:
+    """Rappel des MCPs incomplets (voir lyra/client/reminders.py) --
+    aussi affiche en one-shot, pas seulement en REPL, sinon un utilisateur
+    qui n'utilise jamais le mode interactif ne le voit jamais."""
+    try:
+        import yaml
+
+        from lyra.client.reminders import print_incomplete_integrations
+        with open(REPO_ROOT / "config.yaml") as f:
+            cfg = yaml.safe_load(f)
+        print_incomplete_integrations(cfg)
+    except Exception:
+        pass
+
+
+def _exec_standalone(argv: list[str]) -> None:
+    """Remplace le process par le main_rag historique (fallback ou interactif)."""
+    os.chdir(REPO_ROOT)
+    os.execv(sys.executable,
+             [sys.executable, str(REPO_ROOT / "main_rag.py"), "--rag-enhanced",
+              *argv])
+
+
+def run_oneshot_via_daemon(request: str, args: argparse.Namespace) -> int:
+    """Requete one-shot via le demon. Retourne un code de sortie, ou -1 si le
+    demon est indisponible (le caller bascule en standalone)."""
+    from lyra.client.launcher import ensure_daemon
+    from lyra.client.render import answer_ask, render_output, render_progress
+    from lyra.daemon.protocol import ChannelClosed
+    from modules import ui
+
+    waiting = {"shown": False}
+
+    def on_wait():
+        if not waiting["shown"]:
+            print(f"{ui.Colors.DIM}  (re)demarrage du demon Lyra...{ui.Colors.RESET}",
+                  flush=True)
+            waiting["shown"] = True
+
+    channel, greeting = ensure_daemon(on_wait=on_wait)
+    if greeting:
+        ui.print_lyra(greeting)
+    if channel is None:
+        return -1  # demon introuvable -> standalone
+
+    _print_incomplete_integrations_reminder()
+    print(f"{ui.Colors.CYAN}LYRA{ui.Colors.RESET}  {request}", flush=True)
+
+    mode = "performance" if args.performance else "default"
+    try:
+        channel.send({"type": "hello", "session": "default", "client": "oneshot"})
+        ready = channel.recv(timeout=10)
+        if ready.get("type") != "ready":
+            return -1
+        channel.send({
+            "type": "request",
+            "text": request,
+            "options": {"mode": mode, "yes": args.yes,
+                        "verbose": args.verbose, "interactive": False},
+        })
+        while True:
+            message = channel.recv(timeout=600)
+            mtype = message.get("type")
+            if mtype == "output":
+                render_output(message)
+            elif mtype == "progress":
+                render_progress(message, verbose=args.verbose)
+            elif mtype == "busy":
+                ui.print_info(message.get("text", "Lyra est occupee..."))
+            elif mtype == "ask":
+                answer = answer_ask(message)
+                if answer is None:
+                    channel.send({"type": "cancel"})
+                    ui.print_warning("Annule.")
+                    return 2
+                channel.send({"type": "answer", "value": answer})
+            elif mtype == "result":
+                return int(message.get("exit_code", 1))
+            elif mtype == "error":
+                ui.print_error(message.get("text", "erreur protocole"))
+                return 1
+    except (ChannelClosed, TimeoutError, ValueError) as e:
+        ui.print_error(f"Connexion au demon perdue: {e}")
+        return 1
+    except KeyboardInterrupt:
+        try:
+            channel.send({"type": "cancel"})
+        except Exception:
+            pass
+        print()
+        ui.print_warning("Annule.")
+        return 2
+    finally:
+        channel.close()
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Lyra client", add_help=True)
+    parser.add_argument("--version", action="version",
+                        version=f"{PACKAGE_NAME} {_package_version()}")
+    parser.add_argument("request", nargs="?", default=None)
+    parser.add_argument("--vocal", action="store_true")
+    parser.add_argument("-p", "--performance", action="store_true")
+    parser.add_argument("--config", "-c", default="config.yaml")
+    parser.add_argument("--check", action="store_true")
+    parser.add_argument("--rag-enhanced", action="store_true")  # implicite
+    parser.add_argument("--debug", "-d", action="store_true")
+    parser.add_argument("--verbose", "-v", action="store_true")
+    parser.add_argument("--yes", "-y", action="store_true")
+    parser.add_argument("--standalone", action="store_true",
+                        help="Forcer le mode historique sans demon")
+    args, unknown = parser.parse_known_args()
+
+    # Reconstituer les argv a transmettre au standalone (sans --standalone)
+    passthrough = [a for a in sys.argv[1:] if a not in ("--standalone", "--rag-enhanced")]
+
+    one_shot = args.request is not None
+    daemon_capable = (
+        not args.standalone and not args.vocal and not args.check
+        and not args.debug and not unknown and args.config == "config.yaml"
+    )
+
+    if daemon_capable and one_shot:
+        code = run_oneshot_via_daemon(args.request, args)
+        if code >= 0:
+            return code
+        print("  [!] Demon indisponible, bascule en mode standalone (plus lent)",
+              file=sys.stderr)
+    elif daemon_capable and not one_shot:
+        # REPL interactif branche sur le demon (vocal reste standalone)
+        from lyra.client.repl import run_repl
+        code = run_repl(args)
+        if code >= 0:
+            return code
+        print("  [!] Demon indisponible, bascule en mode standalone (plus lent)",
+              file=sys.stderr)
+
+    _exec_standalone(passthrough)
+    return 1  # jamais atteint (execv)
+
+
+if __name__ == "__main__":
+    sys.path.insert(0, str(REPO_ROOT))
+    os.chdir(REPO_ROOT)
+    sys.exit(main())

lyra/client/launcher.py

@@ -0,0 +1,121 @@
+"""
+Lyra Client - Cycle de vie du demon cote client.
+
+Spec utilisateur : si le demon est mort, le client previent (notification +
+message d'accueil facon Lyra expliquant la raison du crash), le relance
+(systemd d'abord, spawn direct sinon), et bascule en standalone si le demon
+refuse de demarrer.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Optional
+
+from lyra.daemon import state as daemon_state
+from lyra.daemon.protocol import SOCKET_PATH, LineChannel, connect
+
+REPO_ROOT = Path(__file__).resolve().parent.parent.parent
+DAEMON_LOG = Path.home() / ".lyra" / "logs" / "daemon.log"
+START_TIMEOUT = 240.0  # init complete (modeles + ChromaDB) ~15-25s, marge large
+
+
+def try_connect() -> Optional[LineChannel]:
+    try:
+        return connect(SOCKET_PATH)
+    except OSError:
+        return None
+
+
+def _systemd_unit_exists() -> bool:
+    try:
+        result = subprocess.run(
+            ["systemctl", "--user", "cat", "lyra-daemon.service"],
+            capture_output=True, timeout=3,
+        )
+        return result.returncode == 0
+    except (OSError, subprocess.TimeoutExpired):
+        return False
+
+
+def _notify_crash(reason: str) -> None:
+    """Notification desktop best-effort (spec: prevenir en cas de crash)."""
+    try:
+        subprocess.run(
+            ["notify-send", "-a", "Lyra", "Lyra a redemarre",
+             f"Raison du dernier arret : {reason}"],
+            capture_output=True, timeout=3,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        pass
+
+
+def start_daemon() -> bool:
+    """Demarre le demon (systemd si l'unit existe, sinon spawn detache)."""
+    if _systemd_unit_exists():
+        try:
+            result = subprocess.run(
+                ["systemctl", "--user", "start", "lyra-daemon.service"],
+                capture_output=True, timeout=10,
+            )
+            if result.returncode == 0:
+                return True
+        except (OSError, subprocess.TimeoutExpired):
+            pass
+        # systemd a echoue -> tenter le spawn direct quand meme
+
+    DAEMON_LOG.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        with open(DAEMON_LOG, "a") as log:
+            subprocess.Popen(
+                [sys.executable, "-m", "lyra.daemon"],
+                cwd=REPO_ROOT,
+                stdout=log,
+                stderr=log,
+                start_new_session=True,  # survit a la fin du client
+            )
+        return True
+    except OSError:
+        return False
+
+
+def wait_for_daemon(timeout: float = START_TIMEOUT,
+                    on_wait=None) -> Optional[LineChannel]:
+    """Attend que le socket accepte les connexions."""
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        channel = try_connect()
+        if channel is not None:
+            return channel
+        if on_wait:
+            on_wait()
+        time.sleep(0.5)
+    return None
+
+
+def ensure_daemon(on_wait=None) -> tuple[Optional[LineChannel], Optional[str]]:
+    """Connexion au demon, en le (re)lancant si besoin.
+
+    Returns:
+        (channel, greeting) — greeting est le message d'accueil facon Lyra a
+        afficher si le demon avait crashe (None sinon). channel est None si le
+        demon n'a pas pu demarrer (le client doit basculer en standalone).
+    """
+    channel = try_connect()
+    if channel is not None:
+        return channel, None
+
+    crash = daemon_state.read_crash_info()
+    greeting = None
+    if crash is not None:
+        greeting = daemon_state.crash_greeting(crash)
+        _notify_crash(crash.get("reason", "inconnue"))
+
+    if not start_daemon():
+        return None, greeting
+
+    channel = wait_for_daemon(on_wait=on_wait)
+    return channel, greeting

lyra/client/reminders.py

@@ -0,0 +1,26 @@
+"""Rappels affiches au demarrage du client (REPL et one-shot).
+
+incomplete_integrations est ecrit dans config.yaml par installer/core/
+steps/config.py quand un MCP selectionne a l'install est reste incomplet
+(device injoignable, paquet casse...) -- voir installer/core/pipeline.py
+StepDef.optional. Non bloquant pour Lyra, mais l'utilisateur doit savoir
+que cette partie ne fonctionnera pas tant que non reconfiguree.
+"""
+from __future__ import annotations
+
+from modules import ui
+
+
+def print_incomplete_integrations(cfg: dict) -> None:
+    incomplete = cfg.get("incomplete_integrations") or []
+    if not incomplete:
+        return
+    print(f"{ui.Colors.YELLOW}[!] Integrations incompletes :{ui.Colors.RESET}")
+    for item in incomplete:
+        label = item.get("label", item.get("id", "?"))
+        reason = item.get("reason", "raison inconnue")
+        print(f"{ui.Colors.YELLOW}    - {label} : {reason}{ui.Colors.RESET}")
+    print(f"{ui.Colors.YELLOW}    Cette partie ne fonctionnera pas tant que "
+          f"non configuree. Relance ./installer/install.sh pour la "
+          f"reconfigurer, ou complete config.yaml/secrets.yaml a la "
+          f"main.{ui.Colors.RESET}")

lyra/client/render.py

@@ -0,0 +1,102 @@
+"""
+Lyra Client - Rendu terminal des messages du protocole.
+
+Reutilise modules/ui.py (stdlib pur, demarrage instantane) pour un rendu
+identique au mode historique : memes panneaux, memes couleurs.
+"""
+
+from __future__ import annotations
+
+import sys
+from typing import Optional
+
+from modules import ui
+
+
+def render_output(message: dict) -> None:
+    """Affiche un message {"type": "output", ...}."""
+    kind = message.get("kind", "plain")
+    text = message.get("text", "")
+    if kind == "info":
+        ui.print_info(text)
+    elif kind == "success":
+        ui.print_success(text)
+    elif kind == "warning":
+        ui.print_warning(text)
+    elif kind == "error":
+        print(f"\n{ui.Colors.RED}{text}{ui.Colors.RESET}")
+    elif kind == "lyra":
+        ui.print_lyra(text)
+    elif kind == "lyra_tag":
+        ui.print_lyra_tag(text)
+    elif kind == "tool_call":
+        ui.print_tool_call(message.get("tool", "?"),
+                           message.get("arguments", {}),
+                           message.get("vm_state"))
+    elif kind == "tool_result":
+        ui.print_tool_result(text, success=message.get("success", True),
+                             raw_error=message.get("raw_error"))
+    else:  # plain
+        print(text)
+
+
+def render_progress(message: dict, verbose: bool = False) -> None:
+    """Affiche un message {"type": "progress", ...} (verbose uniquement)."""
+    if not verbose:
+        return
+    step = message.get("step", "")
+    data = message.get("data", {})
+    if step == "acknowledgement":
+        print(f"  {ui.Colors.CYAN}[lyra] {data.get('message', '')}{ui.Colors.RESET}",
+              flush=True)
+        return
+    score = data.get("score", 0.0)
+    if score > 0.80:
+        color = ui.Colors.GREEN
+    elif score >= 0.50:
+        color = ui.Colors.YELLOW
+    else:
+        color = ui.Colors.RED
+    if step == "before_llm":
+        level = data.get("confidence_level", "medium")
+        tool = data.get("tool", "?").split(".")[-1].replace("_", " ")
+        score_str = f"{score:.2f}" if score else "?"
+        print(f"  {color}[rag] {tool} score={score_str} ({level}){ui.Colors.RESET}",
+              flush=True)
+    else:
+        tool = data.get("tool", "") or data.get("server", "")
+        if tool:
+            score_str = f"{score:.2f}" if score else "?"
+            print(f"  {color}[rag] {step}: {tool} score={score_str}"
+                  f"{ui.Colors.RESET}", flush=True)
+
+
+def answer_ask(message: dict) -> Optional[str]:
+    """Affiche un ask et lit la reponse clavier.
+
+    Returns:
+        La reponse, ou None si l'utilisateur a annule (Ctrl+C / EOF).
+    """
+    kind = message.get("kind", "input")
+    prompt = message.get("prompt", "")
+    payload = message.get("payload", {})
+
+    if kind == "confirm":
+        if payload.get("dangerous"):
+            sys.stdout.write(f"\n{ui.Colors.RED}{prompt}{ui.Colors.RESET} ")
+        else:
+            tag = f"{ui.Colors.BG_ORANGE}{ui.Colors.FG_DARK} Lyra {ui.Colors.RESET}"
+            sys.stdout.write(f"\n{tag} {prompt} ")
+        sys.stdout.flush()
+        try:
+            return input().strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            return None
+
+    # kind == "input" : question libre d'un workflow
+    try:
+        return input(f"{prompt} ")
+    except (EOFError, KeyboardInterrupt):
+        print()
+        return None

lyra/client/repl.py

@@ -0,0 +1,237 @@
+"""
+Lyra Client - REPL interactif branche sur le demon.
+
+Reprend l'experience de main_rag (banniere, live_input + bandeau de taches,
+commandes internes, /setting) mais route les requetes vers le demon :
+demarrage en <1s, pipeline deja chaud, session multi-tours cote demon.
+
+Ce qui reste local au client : l'affichage, le bandeau de taches (lu depuis
+le registre fichier partage ~/.lyra/active_tasks.json), les commandes
+internes et la TUI /setting. Le vocal reste en mode standalone (phase
+ulterieure du chantier demon).
+"""
+
+from __future__ import annotations
+
+import sys
+import time
+from pathlib import Path
+
+from lyra.client.launcher import ensure_daemon
+from lyra.client.reminders import print_incomplete_integrations
+from lyra.client.render import answer_ask, render_output, render_progress
+from lyra.daemon.protocol import ChannelClosed, LineChannel
+from modules import ui
+
+REPO_ROOT = Path(__file__).resolve().parent.parent.parent
+
+
+def _print_banner() -> None:
+    """Banniere v2 enhanced avec les noms de modeles (lecture yaml legere)."""
+    try:
+        import yaml
+        with open(REPO_ROOT / "config.yaml") as f:
+            cfg = yaml.safe_load(f)
+        models = cfg.get("models", {})
+        from main_rag import print_banner
+        print_banner(mode="enhanced",
+                     ephaistos_model=models.get("ephaistos", {}).get("name", "?"),
+                     lyra_model=models.get("lyra", {}).get("name", "?"))
+        print_incomplete_integrations(cfg)
+    except Exception:
+        print(f"{ui.Colors.CYAN}LYRA (demon){ui.Colors.RESET}")
+
+
+def _process_request(channel: LineChannel, text: str, mode: str,
+                     verbose: bool) -> str:
+    """Envoie une requete et deroule les messages jusqu'au result.
+
+    Returns:
+        "done"      : requete terminee, connexion propre et reutilisable
+        "reconnect" : la connexion doit etre remplacee. C'est le cas apres
+            TOUTE annulation : si on arretait de lire apres un cancel, le
+            "result" tardif du demon resterait dans le tampon et serait lu
+            comme premiere reponse de la requete SUIVANTE — toutes les
+            requetes deviendraient silencieuses, decalees d'un cran
+            (bug du 2026-08-11). Connexion neuve = flux garanti propre.
+    """
+    try:
+        channel.send({
+            "type": "request",
+            "text": text,
+            "options": {"mode": mode, "yes": False, "verbose": verbose,
+                        "interactive": True},
+        })
+        while True:
+            message = channel.recv(timeout=600)
+            mtype = message.get("type")
+            if mtype == "output":
+                render_output(message)
+            elif mtype == "progress":
+                render_progress(message, verbose=verbose)
+            elif mtype == "busy":
+                ui.print_info(message.get("text", "Lyra est occupee..."))
+            elif mtype == "ask":
+                answer = answer_ask(message)
+                if answer is None:
+                    ui.print_warning("Annule.")
+                    return "reconnect"
+                channel.send({"type": "answer", "value": answer})
+            elif mtype == "result":
+                return "done"
+            elif mtype == "error":
+                ui.print_error(message.get("text", "erreur protocole"))
+                return "done"
+    except KeyboardInterrupt:
+        print()
+        ui.print_warning("Requete annulee.")
+        return "reconnect"
+    except (ChannelClosed, TimeoutError, ValueError) as e:
+        ui.print_error(f"Connexion au demon perdue: {e}")
+        return "reconnect"
+
+
+def _connect(show_greeting: bool = True):
+    """Connexion + hello. Retourne le channel pret, ou None si demon KO."""
+    channel, greeting = ensure_daemon(on_wait=lambda: None)
+    if greeting and show_greeting:
+        ui.print_lyra(greeting)
+    if channel is None:
+        return None
+    try:
+        channel.send({"type": "hello", "session": "default", "client": "repl"})
+        channel.recv(timeout=10)  # ready
+        return channel
+    except (ChannelClosed, TimeoutError, ValueError):
+        channel.close()
+        return None
+
+
+def run_repl(args) -> int:
+    """Boucle interactive cliente du demon."""
+    from lyra.core.settings import UserSettings
+    from lyra.core.settings_menu import SettingsCallbacks, SettingsMenu
+    from lyra.hestia.background_tasks import BackgroundTaskManager
+
+    user_settings = UserSettings()
+    mode = "performance" if args.performance else user_settings.active_mode()
+
+    _print_banner()
+
+    channel, greeting = ensure_daemon(
+        on_wait=lambda: None)
+    if greeting:
+        ui.print_lyra(greeting)
+    if channel is None:
+        return -1  # bascule standalone geree par l'appelant
+
+    try:
+        channel.send({"type": "hello", "session": "default", "client": "repl"})
+        channel.recv(timeout=10)  # ready
+        channel.send({"type": "health"})
+        health = channel.recv(timeout=180).get("data", {})
+        servers = health.get("mcp_servers", [])
+        if servers:
+            ui.print_success(f"MCP: {', '.join(servers)} ({len(servers)} serveurs)"
+                             f" — demon pret (uptime {health.get('uptime_s', '?')}s)")
+    except (ChannelClosed, TimeoutError, ValueError):
+        return -1
+
+    # Bandeau de taches : manager LOCAL alimente par le registre partage
+    task_manager = BackgroundTaskManager()
+    task_manager.restore_from_registry()
+
+    def _set_mode(new_mode: str):
+        nonlocal mode
+        mode = new_mode
+
+    settings_menu = SettingsMenu(
+        settings=user_settings,
+        models_dir=REPO_ROOT / "models",
+        callbacks=SettingsCallbacks(get_mode=lambda: mode, set_mode=_set_mode),
+    )
+
+    last_interrupt = 0.0  # double Ctrl+C pour quitter
+
+    while True:
+        try:
+            task_manager.restore_from_registry()  # taches lancees via le demon
+            notifs = [n for n in task_manager.get_completed_notifications()
+                      if n.get("success")]
+            if notifs:
+                ui.print_completed_task_notifications(notifs)
+            task_manager.cleanup_completed(max_age_seconds=300)
+
+            user_input = ui.live_input(">>> ", task_manager, mode=mode).strip()
+            if not user_input:
+                continue
+            task_manager.clear_notifications()
+
+            # Menu /setting ouvert : il consomme l'entree
+            if settings_menu.active:
+                ui.print_lyra(settings_menu.handle(user_input))
+                continue
+
+            cmd = user_input.lower().strip().lstrip("/")
+
+            if cmd in ("setting", "settings", "reglages", "parametres"):
+                if sys.stdin.isatty():
+                    from lyra.core.settings_tui import run_settings_tui
+                    run_settings_tui(settings_menu, println=ui.print_lyra)
+                else:
+                    ui.print_lyra(settings_menu.open())
+                continue
+            if cmd in ("quit", "stop", "exit", "q"):
+                print("\nAu revoir!")
+                return 0
+            if cmd in ("clearscreen", "cls"):
+                ui.clear_screen()
+                continue
+            if cmd == "mode":
+                ui.print_info(f"Mode actuel: {mode}")
+                continue
+            if cmd == "mode performance":
+                mode = "performance"
+                ui.print_success("Mode performance active")
+                continue
+            if cmd in ("mode default", "mode normal"):
+                mode = "default"
+                ui.print_success("Mode default active")
+                continue
+            if cmd == "help":
+                print("""
+Commandes internes (avec ou sans prefixe "/"):
+  quit, stop, exit  - Quitter Lyra
+  clearscreen       - Effacer l'ecran
+  /setting          - Reglages (voix TTS, vitesse, mode)
+  mode [performance|default] - Mode actif
+  help              - Cette aide
+Le reste part au demon (pipeline chaud, session multi-tours conservee).
+""")
+                continue
+
+            # Requete -> demon. Apres toute annulation ("reconnect"), on
+            # remplace la connexion : un flux a moitie lu contaminerait
+            # toutes les requetes suivantes (reponses decalees/silencieuses).
+            status = _process_request(channel, user_input, mode, args.verbose)
+            if status == "reconnect":
+                channel.close()
+                channel = _connect(show_greeting=False)
+                if channel is None:
+                    ui.print_error("Demon injoignable — relance lyra pour "
+                                   "basculer en standalone.")
+                    return 1
+
+        except KeyboardInterrupt:
+            # Double Ctrl+C (<1.5s) = quitter, comme le mode historique
+            now = time.monotonic()
+            if now - last_interrupt < 1.5:
+                print("\nAu revoir!")
+                return 0
+            last_interrupt = now
+            print()
+            ui.print_info("Ctrl+C a nouveau pour quitter")
+            continue
+        except EOFError:
+            print("\nAu revoir!")
+            return 0