opsiom-cli 1.0.2__tar.gz → 1.1.0__tar.gz

{opsiom_cli-1.0.2 → opsiom_cli-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opsiom-cli
-Version: 1.0.2
+Version: 1.1.0
 Summary: CLI de chat pour Opsiom, l'assistant IA francophone.
 Author-email: Ton nom <toi@example.com>
 License-Expression: MIT

{opsiom_cli-1.0.2 → opsiom_cli-1.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "opsiom-cli"
-version = "1.0.2"
+version = "1.1.0"
 description = "CLI de chat pour Opsiom, l'assistant IA francophone."
 readme = "README.md"
 requires-python = ">=3.9"

opsiom_cli-1.1.0/src/opsiom_cli/cli.py

@@ -0,0 +1,491 @@
+#!/usr/bin/env python3
+# ============================================================================
+# Opsiom CLI — interface en ligne de commande pour discuter avec Opsiom
+#
+# Design : une seule couleur d'accent, texte de contenu en couleur par
+# défaut du terminal (compatible thèmes clairs et sombres), un spinner
+# discret plutôt que des animations plein écran. Inspiré des CLI d'outils
+# IA professionnels (Claude Code, Mistral CLI).
+#
+# Dépendances : uniquement `requests`
+#   pip install requests
+#
+# Configuration (aucune URL n'est codée en dur dans ce fichier) :
+#   Au premier lancement, le CLI demande l'URL du serveur (et une éventuelle
+#   clé API) puis les enregistre dans ~/.config/opsiom/config.json.
+#   Alternative : variables d'environnement OPSIOM_URL / OPSIOM_API_KEY,
+#   ou options --url / --api-key.
+# ============================================================================
+
+import os
+import sys
+import json
+import time
+import shutil
+import textwrap
+import argparse
+import threading
+import itertools
+from pathlib import Path
+
+try:
+    import requests
+except ImportError:
+    print("Ce CLI nécessite le paquet 'requests'. Installe-le avec : pip install requests")
+    sys.exit(1)
+
+try:
+    import readline  # historique flèche-haut persistant
+except ImportError:
+    readline = None  # absent par défaut sur certains Windows (pyreadline3 comble le manque)
+
+VERSION = "1.1.0"
+CONFIG_PATH = Path.home() / ".config" / "opsiom" / "config.json"
+HISTORY_PATH = Path.home() / ".local" / "share" / "opsiom" / "history"
+TRANSCRIPTS_DIR = Path.home() / "opsiom-conversations"
+
+
+# ----------------------------------------------------------------------------
+# Palette — une seule couleur d'accent, le reste reste en couleur par défaut
+# du terminal. C'est ce qui distingue un outil pro d'une démo colorée : le
+# contenu doit rester lisible sur fond clair ou sombre, sans texte forcé
+# en blanc/noir codé en dur.
+# ----------------------------------------------------------------------------
+
+RESET = "\033[0m"
+BOLD = "\033[1m"
+DIM = "\033[2m"
+HIDE_CURSOR = "\033[?25l"
+SHOW_CURSOR = "\033[?25h"
+
+ACCENT = (150, 130, 235)   # violet discret — prompt, spinner, éléments actifs
+ERROR = (206, 100, 100)    # rouge sobre — erreurs uniquement
+OK = (120, 170, 140)       # vert sobre — statut connecté uniquement
+
+
+def accent(text, bold=False):
+    r, g, b = ACCENT
+    return f"{BOLD if bold else ''}\033[38;2;{r};{g};{b}m{text}{RESET}"
+
+
+def muted(text):
+    return f"{DIM}{text}{RESET}"
+
+
+def error_text(text, bold=False):
+    r, g, b = ERROR
+    return f"{BOLD if bold else ''}\033[38;2;{r};{g};{b}m{text}{RESET}"
+
+
+def ok_text(text):
+    r, g, b = OK
+    return f"\033[38;2;{OK[0]};{OK[1]};{OK[2]}m{text}{RESET}"
+
+
+# ----------------------------------------------------------------------------
+# Marque — un petit repère ASCII discret, affiché une seule fois au
+# démarrage (pas d'animation en boucle : c'est un logo, pas un spectacle).
+# ----------------------------------------------------------------------------
+
+OCTOPUS_MARK = [
+    "    .------.",
+    "   /  o  o  \\",
+    "  |    --    |",
+    "   \\________/",
+    "   /|  |  |\\",
+]
+
+
+def print_header(url, connected, api_key, models_loaded, current_model, show_mark=True):
+    print()
+    if show_mark:
+        for line in OCTOPUS_MARK:
+            print("  " + accent(line))
+        print()
+    print(f"  {accent('Opsiom', bold=True)}  {muted(f'v{VERSION}')}")
+    print(f"  {muted('assistant IA francophone')}")
+    print()
+    status_symbol = ok_text("✓") if connected else error_text("✗")
+    print(f"  {status_symbol} {muted('connecté à')} {url}")
+    print(f"    {muted('auth')}      {muted('clé API' if api_key else 'aucune')}")
+    if models_loaded:
+        print(f"    {muted('modèles')}   {' · '.join(models_loaded)}")
+    if current_model:
+        print(f"    {muted('actif')}     {accent(current_model)}")
+    print()
+
+
+# ----------------------------------------------------------------------------
+# Spinner — une ligne, un caractère braille tournant, un minuteur en
+# direct. C'est la convention de facto des CLI professionnelles (npm,
+# cargo, Claude Code) : discret, informatif, jamais envahissant.
+# ----------------------------------------------------------------------------
+
+SPINNER_FRAMES = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
+
+
+class Spinner:
+    def __init__(self, label="Réflexion"):
+        self.label = label
+        self._stop_event = threading.Event()
+        self._thread = None
+
+    def _run(self):
+        start = time.perf_counter()
+        frames = itertools.cycle(SPINNER_FRAMES)
+        print(HIDE_CURSOR, end="")
+        while not self._stop_event.is_set():
+            elapsed = time.perf_counter() - start
+            frame = next(frames)
+            line = (
+                f"{accent(frame)} {muted(self.label)} {muted(f'{elapsed:0.1f}s')}"
+                f"  {muted('(Ctrl+C pour annuler)')}"
+            )
+            sys.stdout.write("\r\033[K" + line)
+            sys.stdout.flush()
+            time.sleep(0.08)
+        sys.stdout.write("\r\033[K")
+        sys.stdout.write(SHOW_CURSOR)
+        sys.stdout.flush()
+
+    def start(self):
+        self._stop_event.clear()
+        self._thread = threading.Thread(target=self._run, daemon=True)
+        self._thread.start()
+
+    def stop(self):
+        self._stop_event.set()
+        if self._thread:
+            self._thread.join()
+
+
+# ----------------------------------------------------------------------------
+# Historique de saisie persistant
+# ----------------------------------------------------------------------------
+
+def setup_history():
+    if not readline:
+        return
+    HISTORY_PATH.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        readline.read_history_file(HISTORY_PATH)
+    except OSError:
+        pass
+    readline.set_history_length(500)
+
+
+def save_history():
+    if not readline:
+        return
+    try:
+        readline.write_history_file(HISTORY_PATH)
+    except OSError:
+        pass
+
+
+def save_transcript(transcript, filename=None):
+    TRANSCRIPTS_DIR.mkdir(parents=True, exist_ok=True)
+    if not filename:
+        filename = f"opsiom-{time.strftime('%Y%m%d-%H%M%S')}"
+    if not filename.endswith(".md"):
+        filename += ".md"
+    path = TRANSCRIPTS_DIR / filename
+    lines = ["# Conversation Opsiom", ""]
+    for entry in transcript:
+        if entry["role"] == "user":
+            lines.append(f"**Vous :** {entry['text']}")
+        else:
+            lines.append(f"**Opsiom ({entry['model']}) :** {entry['text']}  _({entry['elapsed_ms']} ms)_")
+        lines.append("")
+    path.write_text("\n".join(lines), encoding="utf-8")
+    return path
+
+
+# ----------------------------------------------------------------------------
+# Configuration — aucune URL n'est codée en dur : on lit env / config / prompt
+# ----------------------------------------------------------------------------
+
+def load_config():
+    if CONFIG_PATH.exists():
+        try:
+            return json.loads(CONFIG_PATH.read_text())
+        except (json.JSONDecodeError, OSError):
+            return {}
+    return {}
+
+
+def save_config(config):
+    CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    CONFIG_PATH.write_text(json.dumps(config, indent=2))
+
+
+def prompt_for_config():
+    print(f"  {accent('Configuration initiale', bold=True)}")
+    print(f"  {muted('ces informations te sont transmises par la personne qui héberge Opsiom')}\n")
+    url = input("  URL du serveur : ").strip().rstrip("/")
+    api_key = input("  Clé API (vide si aucune) : ").strip()
+    save = input(muted("  Sauvegarder localement pour la prochaine fois ? [O/n] ")).strip().lower()
+    config = {"url": url, "api_key": api_key}
+    if save in ("", "o", "oui", "y", "yes"):
+        save_config(config)
+        print(muted(f"  → enregistré dans {CONFIG_PATH}\n"))
+    return config
+
+
+def resolve_settings(args):
+    config = {} if args.configure else load_config()
+    url = args.url or os.environ.get("OPSIOM_URL") or config.get("url")
+    api_key = args.api_key or os.environ.get("OPSIOM_API_KEY") or config.get("api_key")
+    if args.configure or not url:
+        new_config = prompt_for_config()
+        url = new_config["url"] or url
+        api_key = new_config["api_key"] or api_key
+    return url, api_key
+
+
+# ----------------------------------------------------------------------------
+# Client API
+# ----------------------------------------------------------------------------
+
+class OpsiomClient:
+    def __init__(self, base_url, api_key=None, timeout=60):
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.session = requests.Session()
+        headers = {"ngrok-skip-browser-warning": "true"}
+        if api_key:
+            headers["X-API-Key"] = api_key
+        self.session.headers.update(headers)
+
+    def health(self):
+        r = self.session.get(f"{self.base_url}/api/health", timeout=10)
+        r.raise_for_status()
+        return r.json()
+
+    def list_models(self):
+        r = self.session.get(f"{self.base_url}/api/models", timeout=10)
+        r.raise_for_status()
+        return r.json()
+
+    def chat(self, message, model=None, **params):
+        payload = {"message": message}
+        if model:
+            payload["model"] = model
+        payload.update(params)
+        r = self.session.post(f"{self.base_url}/api/chat", json=payload, timeout=self.timeout)
+        r.raise_for_status()
+        return r.json()
+
+
+# ----------------------------------------------------------------------------
+# Interface interactive
+# ----------------------------------------------------------------------------
+
+HELP_TEXT = """
+  /model            menu numéroté pour choisir le modèle
+  /model <id|num>   change directement de modèle
+  /models           liste les modèles disponibles
+  /status           réaffiche l'en-tête de connexion
+  /save [nom]       exporte la conversation en Markdown
+  /clear            efface l'écran
+  /help             affiche cette aide
+  /quit, /exit      quitte le CLI
+"""
+
+
+def term_width(default=80):
+    return shutil.get_terminal_size((default, 20)).columns
+
+
+def format_elapsed(ms):
+    return f"{ms} ms" if ms < 1000 else f"{ms / 1000:.1f} s"
+
+
+def print_error(text, detail=None):
+    print(f"  {error_text('✗', bold=True)} {text}")
+    if detail:
+        print(f"    {muted(detail)}")
+
+
+def choose_default_model(models_payload):
+    default = models_payload.get("default")
+    models = models_payload.get("models", [])
+    return default or (models[0]["id"] if models else None)
+
+
+def print_models(models_payload, current_model):
+    for i, m in enumerate(models_payload.get("models", []), start=1):
+        is_current = m["id"] == current_model
+        marker = accent("›") if is_current else " "
+        label = accent(m["label"], bold=True) if is_current else m["label"]
+        detail = f"{m['params']} · {m['id']}"
+        print(f"  {marker} {muted(f'[{i}]')} {label}  {muted(detail)}")
+
+
+def resolve_model_choice(choice, models):
+    if choice.isdigit():
+        idx = int(choice) - 1
+        if 0 <= idx < len(models):
+            return models[idx]["id"]
+        return None
+    ids = {m["id"] for m in models}
+    if choice in ids:
+        return choice
+    matches = [m["id"] for m in models if m["id"].startswith(choice) or m["label"].lower().startswith(choice.lower())]
+    return matches[0] if len(matches) == 1 else None
+
+
+def select_model_interactively(models_payload, current_model):
+    models = models_payload.get("models", [])
+    if not models:
+        print_error("aucun modèle disponible côté serveur.")
+        return current_model
+    print_models(models_payload, current_model)
+    choice = input(f"\n  {muted('Numéro (Entrée pour annuler) :')} ").strip()
+    if not choice:
+        return current_model
+    resolved = resolve_model_choice(choice, models)
+    if resolved is None:
+        print_error(f"choix invalide : '{choice}'")
+        return current_model
+    print(f"  {accent('→')} modèle actif : {accent(resolved, bold=True)}")
+    return resolved
+
+
+def print_assistant_message(text, elapsed_ms):
+    width = max(term_width() - 4, 30)
+    wrapped = textwrap.fill(text, width=width)
+    print()
+    for line in wrapped.split("\n"):
+        print(f"  {line}")
+    print(f"  {muted(format_elapsed(elapsed_ms))}")
+
+
+def run_chat(client: OpsiomClient, url, api_key):
+    setup_history()
+    transcript = []
+    current_model = None
+    models_payload = {"models": []}
+    connected = False
+    models_loaded = []
+
+    try:
+        health = client.health()
+        connected = health.get("status") == "ok"
+        models_loaded = health.get("models_loaded", [])
+    except requests.RequestException:
+        connected = False
+
+    try:
+        models_payload = client.list_models()
+        current_model = choose_default_model(models_payload)
+    except requests.RequestException:
+        pass
+
+    print_header(url, connected, api_key, models_loaded, current_model)
+    print(f"  {muted('Tapez votre message, ou /help pour la liste des commandes.')}\n")
+
+    while True:
+        try:
+            user_input = input(f"{accent('›')} ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            break
+
+        if not user_input:
+            continue
+
+        if user_input.startswith("/"):
+            cmd, *rest = user_input[1:].split(maxsplit=1)
+            arg = rest[0].strip() if rest else ""
+            cmd = cmd.lower()
+
+            if cmd in ("quit", "exit"):
+                break
+            elif cmd == "help":
+                print(muted(HELP_TEXT))
+            elif cmd == "clear":
+                sys.stdout.write("\033[H\033[J")
+                sys.stdout.flush()
+            elif cmd == "status":
+                print_header(url, connected, api_key, models_loaded, current_model, show_mark=False)
+            elif cmd == "save":
+                if not transcript:
+                    print(muted("  rien à enregistrer pour l'instant."))
+                else:
+                    path = save_transcript(transcript, arg or None)
+                    print(f"  {accent('→')} enregistré dans {path}")
+            elif cmd == "models":
+                try:
+                    models_payload = client.list_models()
+                    print_models(models_payload, current_model)
+                except requests.RequestException as e:
+                    print_error("impossible de récupérer les modèles", str(e))
+            elif cmd == "model":
+                if not arg:
+                    current_model = select_model_interactively(models_payload, current_model)
+                else:
+                    resolved = resolve_model_choice(arg, models_payload.get("models", [])) or arg
+                    current_model = resolved
+                    print(f"  {accent('→')} modèle actif : {accent(resolved, bold=True)}")
+            else:
+                print_error(f"commande inconnue : /{cmd}")
+            print()
+            continue
+
+        transcript.append({"role": "user", "text": user_input})
+
+        spinner = Spinner(label="Réflexion")
+        spinner.start()
+        start_time = time.perf_counter()
+        try:
+            result = client.chat(user_input, model=current_model)
+        except KeyboardInterrupt:
+            spinner.stop()
+            print(muted("  (requête annulée)\n"))
+            continue
+        except requests.RequestException as e:
+            spinner.stop()
+            print_error("la requête a échoué", str(e))
+            print()
+            continue
+        spinner.stop()
+        elapsed_ms = int((time.perf_counter() - start_time) * 1000)
+
+        response_text = result.get("response", "(réponse vide)")
+        used_model = result.get("model", current_model or "?")
+        print_assistant_message(response_text, elapsed_ms)
+        print()
+        transcript.append({"role": "assistant", "text": response_text, "model": used_model, "elapsed_ms": elapsed_ms})
+
+    save_history()
+
+
+# ----------------------------------------------------------------------------
+# Point d'entrée
+# ----------------------------------------------------------------------------
+
+def main():
+    parser = argparse.ArgumentParser(prog="opsiom", description="CLI de chat pour Opsiom")
+    parser.add_argument("--url", default=None, help="URL du serveur Opsiom (sinon config/prompt)")
+    parser.add_argument("--api-key", default=None, help="clé API si le serveur en exige une")
+    parser.add_argument("--configure", action="store_true", help="reconfigure l'URL/clé et les réenregistre")
+    parser.add_argument("--no-logo", action="store_true", help="masque le repère ASCII au démarrage")
+    parser.add_argument("--version", action="version", version=f"opsiom-cli {VERSION}")
+    args = parser.parse_args()
+
+    url, api_key = resolve_settings(args)
+    if not url:
+        print_error("aucune URL configurée, abandon.")
+        sys.exit(1)
+
+    client = OpsiomClient(url, api_key=api_key)
+    if args.no_logo:
+        global OCTOPUS_MARK
+        OCTOPUS_MARK = []
+    run_chat(client, url, api_key)
+    print(muted("À bientôt.\n"))
+
+
+if __name__ == "__main__":
+    main()

{opsiom_cli-1.0.2 → opsiom_cli-1.1.0}/src/opsiom_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opsiom-cli
-Version: 1.0.2
+Version: 1.1.0
 Summary: CLI de chat pour Opsiom, l'assistant IA francophone.
 Author-email: Ton nom <toi@example.com>
 License-Expression: MIT

opsiom_cli-1.0.2/src/opsiom_cli/cli.py

@@ -1,712 +0,0 @@
-#!/usr/bin/env python3
-# ============================================================================
-# Opsiom CLI — interface en ligne de commande pour discuter avec Opsiom
-# Thème violet / rouge / rose. Mascotte poulpe procédurale avec plusieurs
-# animations distinctes : respiration, ondulation des tentacules, clin
-# d'œil, salut d'accueil, bulles de réflexion, et nuage d'encre en cas
-# d'erreur.
-#
-# Dépendances : uniquement `requests`
-#   pip install requests
-#
-# Configuration (aucune URL n'est codée en dur dans ce fichier) :
-#   Au premier lancement, le CLI demande l'URL du serveur (et une éventuelle
-#   clé API) puis les enregistre dans ~/.config/opsiom/config.json.
-#   Alternative : variables d'environnement OPSIOM_URL / OPSIOM_API_KEY,
-#   ou options --url / --api-key.
-# ============================================================================
-
-import os
-import sys
-import json
-import time
-import shutil
-import textwrap
-import argparse
-import threading
-import itertools
-from pathlib import Path
-
-try:
-    import requests
-except ImportError:
-    print("Ce CLI nécessite le paquet 'requests'. Installe-le avec : pip install requests")
-    sys.exit(1)
-
-try:
-    import readline  # active l'historique flèche-haut et son édition de ligne
-except ImportError:
-    readline = None  # non disponible nativement sur certains Windows (pyreadline3 comble le manque)
-
-VERSION = "1.0.2"
-CONFIG_PATH = Path.home() / ".config" / "opsiom" / "config.json"
-HISTORY_PATH = Path.home() / ".local" / "share" / "opsiom" / "history"
-TRANSCRIPTS_DIR = Path.home() / "opsiom-conversations"
-
-
-def setup_history():
-    if not readline:
-        return
-    HISTORY_PATH.parent.mkdir(parents=True, exist_ok=True)
-    try:
-        readline.read_history_file(HISTORY_PATH)
-    except OSError:
-        pass
-    readline.set_history_length(500)
-
-
-def save_history():
-    if not readline:
-        return
-    try:
-        readline.write_history_file(HISTORY_PATH)
-    except OSError:
-        pass
-
-
-def save_transcript(transcript, filename=None):
-    TRANSCRIPTS_DIR.mkdir(parents=True, exist_ok=True)
-    if not filename:
-        filename = f"opsiom-{time.strftime('%Y%m%d-%H%M%S')}"
-    if not filename.endswith(".md"):
-        filename += ".md"
-    path = TRANSCRIPTS_DIR / filename
-    lines = ["# Conversation Opsiom", ""]
-    for entry in transcript:
-        if entry["role"] == "user":
-            lines.append(f"**Vous :** {entry['text']}")
-        else:
-            lines.append(f"**Opsiom ({entry['model']}) :** {entry['text']}  _({entry['elapsed_ms']} ms)_")
-        lines.append("")
-    path.write_text("\n".join(lines), encoding="utf-8")
-    return path
-
-
-# ----------------------------------------------------------------------------
-# Palette — dégradé violet -> rose -> rouge, en vraies couleurs 24 bits (ANSI)
-# ----------------------------------------------------------------------------
-
-RESET = "\033[0m"
-BOLD = "\033[1m"
-HIDE_CURSOR = "\033[?25l"
-SHOW_CURSOR = "\033[?25h"
-
-GRADIENT_STOPS = [
-    (124, 58, 199),
-    (168, 60, 178),
-    (214, 62, 140),
-    (235, 74, 96),
-]
-ACCENT = (222, 90, 176)
-MUTED = (150, 110, 150)
-USER_COLOR = (235, 130, 190)
-ERROR_COLOR = (235, 90, 90)
-SUCCESS_COLOR = (180, 230, 190)
-
-
-def rgb(color, text, bold=False):
-    r, g, b = color
-    prefix = BOLD if bold else ""
-    return f"{prefix}\033[38;2;{r};{g};{b}m{text}{RESET}"
-
-
-def _lerp(a, b, t):
-    return tuple(int(a[i] + (b[i] - a[i]) * t) for i in range(3))
-
-
-def gradient_line(text, stops=GRADIENT_STOPS, bold=False):
-    n = max(len(text) - 1, 1)
-    segments = len(stops) - 1
-    out = []
-    prefix = BOLD if bold else ""
-    for i, ch in enumerate(text):
-        t = (i / n) * segments
-        seg = min(int(t), segments - 1)
-        local_t = t - seg
-        r, g, b = _lerp(stops[seg], stops[seg + 1], local_t)
-        out.append(f"{prefix}\033[38;2;{r};{g};{b}m{ch}")
-    return "".join(out) + RESET
-
-
-def gradient_lines(lines, stops=GRADIENT_STOPS):
-    n = max(len(lines) - 1, 1)
-    segments = len(stops) - 1
-    out = []
-    for i, line in enumerate(lines):
-        t = (i / n) * segments
-        seg = min(int(t), segments - 1)
-        local_t = t - seg
-        color = _lerp(stops[seg], stops[seg + 1], local_t)
-        out.append(rgb(color, line))
-    return out
-
-
-def gradient_block(lines, stops=GRADIENT_STOPS):
-    return "\n".join(gradient_lines(lines, stops))
-
-
-def draw_panel(lines_with_colors, min_width=46):
-    """Panneau encadré (box-drawing) : une couleur unie par ligne, largeur auto."""
-    plain_texts = [t for t, _ in lines_with_colors]
-    content_width = max(min_width, max((len(t) for t in plain_texts), default=0) + 2)
-    top = "╭" + "─" * (content_width + 2) + "╮"
-    bottom = "╰" + "─" * (content_width + 2) + "╯"
-    out = [rgb(ACCENT, top)]
-    for text, color in lines_with_colors:
-        padded = text.ljust(content_width)
-        out.append(rgb(ACCENT, "│") + " " + rgb(color, padded) + " " + rgb(ACCENT, "│"))
-    out.append(rgb(ACCENT, bottom))
-    return "\n".join(out)
-
-
-# ----------------------------------------------------------------------------
-# La mascotte — un poulpe construit à partir de gabarits (tête fixe, yeux /
-# bouche / tentacules interchangeables) pour composer beaucoup de frames
-# différentes sans tout redessiner à la main à chaque fois.
-# ----------------------------------------------------------------------------
-
-FRAME_HEIGHT = 13
-
-EYES_OPEN = ("◉", "◉")
-EYES_BLINK = ("─", "─")
-EYES_WINK = ("◉", "◕")
-EYES_SAD = ("×", "×")
-
-MOUTH_NEUTRAL = "⌣"
-MOUTH_SAD = "⌢"
-MOUTH_OPEN = "○"
-
-TENTACLES_REST = [
-    "            /  /     |     \\  \\",
-    "           (  (      |      )  )",
-    "            \\  \\     |     /  /",
-    "             `._\\    |    /_.'",
-]
-TENTACLES_REST_CUPS = [
-    "            /  /    o|o    \\  \\",
-    "           (  (      |      )  )",
-    "            \\  \\    o|o   /  /",
-    "             `._\\    |    /_.'",
-]
-TENTACLES_LEFT = [
-    "            \\   /    |    \\   /",
-    "            (  (     |     )  )",
-    "            /   \\    |    /   \\",
-    "            -'  `._  |  _.'  `- ",
-]
-TENTACLES_RIGHT = [
-    "            /   \\    |    /   \\",
-    "           (  )      |      (  ) ",
-    "            \\   /    |    \\   /",
-    "               `-'  _|_   `-'",
-]
-TENTACLES_DROOP = [
-    "           ~ /  \\    |    /  \\ ~",
-    "           ~ (    )  |   (    ) ~",
-    "           ~ \\  /    |    \\  / ~",
-    "               *   `.|.'   *",
-]
-
-
-def build_frame(top, eyes, mouth, tentacles, bottom=""):
-    left_eye, right_eye = eyes
-    return [
-        top,
-        "                 .───────.",
-        "              .─'         '─.",
-        f"             /   {left_eye}       {right_eye}   \\",
-        "            |                 |",
-        f"            |        {mouth}        |",
-        "             \\               /",
-        "              '─..-----..─'",
-        tentacles[0],
-        tentacles[1],
-        tentacles[2],
-        tentacles[3],
-        bottom,
-    ]
-
-
-# --- Respiration au repos (2 frames) ---------------------------------------
-FRAMES_BREATHE = [
-    build_frame("", EYES_OPEN, MOUTH_NEUTRAL, TENTACLES_REST),
-    build_frame("", EYES_OPEN, MOUTH_NEUTRAL, TENTACLES_REST_CUPS),
-]
-
-# --- Clin d'œil, inséré de temps en temps dans les cycles -------------------
-FRAME_BLINK = build_frame("", EYES_BLINK, MOUTH_NEUTRAL, TENTACLES_REST)
-
-# --- Ondulation des tentacules (4 frames) -----------------------------------
-FRAMES_WAVE = [
-    build_frame("", EYES_OPEN, MOUTH_NEUTRAL, TENTACLES_LEFT),
-    build_frame("", EYES_OPEN, MOUTH_NEUTRAL, TENTACLES_REST_CUPS),
-    build_frame("", EYES_OPEN, MOUTH_NEUTRAL, TENTACLES_RIGHT),
-    FRAME_BLINK,
-]
-
-# --- Bulles de réflexion qui montent (utilisées pendant l'appel réseau) ----
-_BUBBLE_STAGES = ["", "                                .", "                                 o",
-                  "                                  O", "                                   0",
-                  "                                    °", ""]
-_THINKING_TENTACLES = itertools.cycle([TENTACLES_REST, TENTACLES_LEFT, TENTACLES_REST_CUPS, TENTACLES_RIGHT])
-FRAMES_THINKING = [
-    build_frame(bubble, EYES_BLINK if i == 3 else EYES_OPEN, MOUTH_NEUTRAL, next(_THINKING_TENTACLES))
-    for i, bubble in enumerate(_BUBBLE_STAGES)
-]
-
-# --- Salut d'accueil : un tentacule se lève et fait coucou -----------------
-FRAMES_GREETING = [
-    [
-        "                                      o",
-        "                 .───────.           /",
-        "              .─'         '─.      _/",
-        "             /   ◉       ◕   \\",
-        "            |                 |",
-        "            |        ⌣        |",
-        "             \\               /",
-        "              '─..-----..─'",
-        "            /  /     |     \\  \\",
-        "           (  (      |      )  )",
-        "            \\  \\     |     /  /",
-        "             `._\\    |    /_.'",
-        "",
-    ],
-    [
-        "                 \\   o",
-        "                 .───────.  \\",
-        "              .─'         '─.",
-        "             /   ◕       ◉   \\",
-        "            |                 |",
-        "            |        ⌣        |",
-        "             \\               /",
-        "              '─..-----..─'",
-        "            /  /     |     \\  \\",
-        "           (  (      |      )  )",
-        "            \\  \\     |     /  /",
-        "             `._\\    |    /_.'",
-        "",
-    ],
-    build_frame("", EYES_WINK, MOUTH_NEUTRAL, TENTACLES_REST),
-    build_frame("", EYES_OPEN, MOUTH_NEUTRAL, TENTACLES_REST),
-]
-
-# --- Nuage d'encre + mine déconfite (erreur réseau) -------------------------
-FRAMES_ERROR = [
-    build_frame("       .     *", EYES_SAD, MOUTH_SAD, TENTACLES_DROOP, "      *   ~   ."),
-    build_frame("    *    .   *", EYES_SAD, MOUTH_SAD, TENTACLES_DROOP, "   .   ~    *   ~   ."),
-]
-
-# --- Petite étincelle affichée brièvement après une réponse réussie --------
-SPARKLE_FRAMES = ["  ✦", "  ·  ✦  ·", " ˚  ·  ✦  ·  ˚"]
-
-TITLE = [
-    " ██████╗ ██████╗ ███████╗██╗ ██████╗ ███╗   ███╗",
-    "██╔═══██╗██╔══██╗██╔════╝██║██╔═══██╗████╗ ████║",
-    "██║   ██║██████╔╝███████╗██║██║   ██║██╔████╔██║",
-    "██║   ██║██╔═══╝ ╚════██║██║██║   ██║██║╚██╔╝██║",
-    "╚██████╔╝██║     ███████║██║╚██████╔╝██║ ╚═╝ ██║",
-    " ╚═════╝ ╚═╝     ╚══════╝╚═╝ ╚═════╝ ╚═╝     ╚═╝",
-]
-
-
-# ----------------------------------------------------------------------------
-# Moteur d'animation générique — anime n'importe quelle liste de frames,
-# avec ou sans étiquette de texte sous le poulpe.
-# ----------------------------------------------------------------------------
-
-class OctopusAnimation:
-    def __init__(self, frames, label=None, interval=0.2, loop=True, dynamic=None):
-        self.frames = frames
-        self.label = label
-        self.interval = interval
-        self.loop = loop
-        self.dynamic = dynamic  # callable optionnel -> suffixe texte (ex: minuteur en direct)
-        self._stop_event = threading.Event()
-        self._thread = None
-
-    def _iter_frames(self):
-        return itertools.cycle(self.frames) if self.loop else iter(self.frames)
-
-    def _run(self):
-        dots = itertools.cycle(["   ", ".  ", ".. ", "..."]) if (self.label and not self.dynamic) else None
-        n_lines = FRAME_HEIGHT + (1 if self.label else 0)
-        print(HIDE_CURSOR, end="")
-        first = True
-        for frame in self._iter_frames():
-            if self._stop_event.is_set():
-                break
-            if not first:
-                sys.stdout.write(f"\033[{n_lines}A")
-            first = False
-            for line in gradient_lines(frame):
-                sys.stdout.write(line + "\033[K\n")
-            if self.label:
-                suffix = self.dynamic() if self.dynamic else next(dots)
-                sys.stdout.write(rgb(ACCENT, f"  {self.label}{suffix}") + "\033[K\n")
-            sys.stdout.flush()
-            time.sleep(self.interval)
-        sys.stdout.write(f"\033[{n_lines}A")
-        for _ in range(n_lines):
-            sys.stdout.write("\033[K\n")
-        sys.stdout.write(f"\033[{n_lines}A")
-        sys.stdout.write(SHOW_CURSOR)
-        sys.stdout.flush()
-
-    def start(self):
-        self._stop_event.clear()
-        self._thread = threading.Thread(target=self._run, daemon=True)
-        self._thread.start()
-
-    def stop(self):
-        self._stop_event.set()
-        if self._thread:
-            self._thread.join()
-
-    def play_once_blocking(self):
-        """Joue la séquence une fois, sans thread, puis rend la main (pour l'intro)."""
-        self.loop = False
-        print(HIDE_CURSOR, end="")
-        for frame in self.frames:
-            sys.stdout.write("\033[H\033[J")
-            sys.stdout.write("\n" + gradient_block(frame) + "\n")
-            sys.stdout.flush()
-            time.sleep(self.interval)
-        print(SHOW_CURSOR, end="")
-
-
-def print_intro_animation():
-    OctopusAnimation(FRAMES_GREETING + [FRAMES_BREATHE[0]], interval=0.22).play_once_blocking()
-    sys.stdout.write("\033[H\033[J")
-    print()
-    print(gradient_block(TITLE))
-    print(rgb(MUTED, f"                — assistant IA francophone · v{VERSION} —\n"))
-
-
-def flash_sparkle():
-    """Étincelle furtive affichée juste avant une réponse réussie."""
-    print(HIDE_CURSOR, end="")
-    for frame in SPARKLE_FRAMES:
-        sys.stdout.write("\r" + rgb(SUCCESS_COLOR, frame) + "\033[K")
-        sys.stdout.flush()
-        time.sleep(0.08)
-    sys.stdout.write("\r\033[K")
-    sys.stdout.write(SHOW_CURSOR)
-    sys.stdout.flush()
-
-
-def show_error_animation():
-    """Nuage d'encre + mine déconfite, joué deux fois puis nettoyé."""
-    OctopusAnimation(FRAMES_ERROR, interval=0.3, loop=False)._run()
-
-
-# ----------------------------------------------------------------------------
-# Configuration — aucune URL n'est codée en dur : on lit env / config / prompt
-# ----------------------------------------------------------------------------
-
-def load_config():
-    if CONFIG_PATH.exists():
-        try:
-            return json.loads(CONFIG_PATH.read_text())
-        except (json.JSONDecodeError, OSError):
-            return {}
-    return {}
-
-
-def save_config(config):
-    CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
-    CONFIG_PATH.write_text(json.dumps(config, indent=2))
-
-
-def prompt_for_config():
-    print(rgb(ACCENT, "Configuration initiale d'Opsiom CLI", bold=True))
-    print(rgb(MUTED, "  (ces informations te sont normalement transmises par la personne qui héberge Opsiom)\n"))
-    url = input(rgb(USER_COLOR, "URL du serveur Opsiom : ")).strip().rstrip("/")
-    api_key = input(rgb(USER_COLOR, "Clé API (laisser vide si aucune) : ")).strip()
-    save = input(rgb(MUTED, "Sauvegarder ces informations localement pour la prochaine fois ? [O/n] ")).strip().lower()
-    config = {"url": url, "api_key": api_key}
-    if save in ("", "o", "oui", "y", "yes"):
-        save_config(config)
-        print(rgb(MUTED, f"  → enregistré dans {CONFIG_PATH}\n"))
-    return config
-
-
-def resolve_settings(args):
-    config = {} if args.configure else load_config()
-    url = args.url or os.environ.get("OPSIOM_URL") or config.get("url")
-    api_key = args.api_key or os.environ.get("OPSIOM_API_KEY") or config.get("api_key")
-    if args.configure or not url:
-        new_config = prompt_for_config()
-        url = new_config["url"] or url
-        api_key = new_config["api_key"] or api_key
-    return url, api_key
-
-
-# ----------------------------------------------------------------------------
-# Client API
-# ----------------------------------------------------------------------------
-
-class OpsiomClient:
-    def __init__(self, base_url, api_key=None, timeout=60):
-        self.base_url = base_url.rstrip("/")
-        self.timeout = timeout
-        self.session = requests.Session()
-        headers = {"ngrok-skip-browser-warning": "true"}
-        if api_key:
-            headers["X-API-Key"] = api_key
-        self.session.headers.update(headers)
-
-    def health(self):
-        r = self.session.get(f"{self.base_url}/api/health", timeout=10)
-        r.raise_for_status()
-        return r.json()
-
-    def list_models(self):
-        r = self.session.get(f"{self.base_url}/api/models", timeout=10)
-        r.raise_for_status()
-        return r.json()
-
-    def chat(self, message, model=None, **params):
-        payload = {"message": message}
-        if model:
-            payload["model"] = model
-        payload.update(params)
-        r = self.session.post(f"{self.base_url}/api/chat", json=payload, timeout=self.timeout)
-        r.raise_for_status()
-        return r.json()
-
-
-# ----------------------------------------------------------------------------
-# Interface interactive
-# ----------------------------------------------------------------------------
-
-HELP_TEXT = """
-Commandes disponibles :
-  /model            menu numéroté pour choisir le modèle
-  /model <id|num>   change directement de modèle (ex: /model small, /model 2)
-  /models           liste les modèles disponibles
-  /status           réaffiche le panneau de connexion
-  /save [nom]       exporte la conversation en Markdown (~/opsiom-conversations/)
-  /clear            efface l'écran
-  /help             affiche cette aide
-  /quit, /exit      quitte le CLI (Ctrl+C pendant une réponse : annule juste cette requête)
-"""
-
-
-def term_width(default=76):
-    return shutil.get_terminal_size((default, 20)).columns
-
-
-def print_separator():
-    print(rgb(MUTED, "─" * min(term_width(), 76)))
-
-
-def print_status_panel(url, api_key, connected, models_loaded):
-    status_text = f"● Connecté — {url}" if connected else f"⨯ Non connecté — {url}"
-    status_color = ACCENT if connected else ERROR_COLOR
-    lines = [
-        (f"OPSIOM CLI  ·  v{VERSION}", ACCENT),
-        (status_text, status_color),
-        (f"Authentification : {'clé API fournie' if api_key else 'aucune'}", MUTED),
-        (f"Modèles chargés : {', '.join(models_loaded)}" if models_loaded else "Modèles : indisponible", MUTED),
-    ]
-    print(draw_panel(lines))
-
-
-def print_assistant_message(text, model_id, elapsed_ms=None):
-    prefix_plain = f"Opsiom ({model_id})  ›  "
-    prefix_colored = rgb(ACCENT, "Opsiom", bold=True) + rgb(MUTED, f" ({model_id})") + rgb(MUTED, "  ›  ")
-    width = max(term_width() - len(prefix_plain) - 12, 24)
-    wrapped = textwrap.fill(text, width=width, subsequent_indent=" " * len(prefix_plain))
-    suffix = rgb(MUTED, f"   [{elapsed_ms} ms]") if elapsed_ms is not None else ""
-    print(prefix_colored + wrapped + suffix)
-
-
-def print_error(text):
-    print(rgb(ERROR_COLOR, f"⨯ {text}", bold=True))
-
-
-def choose_default_model(models_payload):
-    default = models_payload.get("default")
-    models = models_payload.get("models", [])
-    if default:
-        return default
-    return models[0]["id"] if models else None
-
-
-def print_models(models_payload, current_model):
-    print(rgb(ACCENT, "Modèles disponibles :", bold=True))
-    for i, m in enumerate(models_payload.get("models", []), start=1):
-        marker = rgb(ACCENT, "●") if m["id"] == current_model else rgb(MUTED, "○")
-        detail = f"({m['params']} — id: {m['id']})"
-        print(f"  {rgb(MUTED, f'[{i}]')} {marker}  {gradient_line(m['label'])}  {rgb(MUTED, detail)}")
-
-
-def resolve_model_choice(choice, models):
-    if choice.isdigit():
-        idx = int(choice) - 1
-        if 0 <= idx < len(models):
-            return models[idx]["id"]
-        return None
-    ids = {m["id"] for m in models}
-    if choice in ids:
-        return choice
-    matches = [m["id"] for m in models if m["id"].startswith(choice) or m["label"].lower().startswith(choice.lower())]
-    return matches[0] if len(matches) == 1 else None
-
-
-def select_model_interactively(models_payload, current_model):
-    models = models_payload.get("models", [])
-    if not models:
-        print_error("aucun modèle disponible côté serveur.")
-        return current_model
-    print_models(models_payload, current_model)
-    choice = input(rgb(USER_COLOR, "Choisis un numéro (ou Entrée pour annuler) : ")).strip()
-    if not choice:
-        return current_model
-    resolved = resolve_model_choice(choice, models)
-    if resolved is None:
-        print_error(f"choix invalide : '{choice}'")
-        return current_model
-    print(rgb(ACCENT, f"→ modèle changé pour '{resolved}'"))
-    return resolved
-
-
-def run_chat(client: OpsiomClient, url, api_key):
-    setup_history()
-    transcript = []
-    current_model = None
-    models_payload = {"models": []}
-    connected = False
-    models_loaded = []
-    try:
-        health = client.health()
-        connected = health.get("status") == "ok"
-        models_loaded = health.get("models_loaded", [])
-    except requests.RequestException:
-        connected = False
-
-    print_status_panel(url, api_key, connected, models_loaded)
-    print()
-
-    try:
-        models_payload = client.list_models()
-        current_model = choose_default_model(models_payload)
-        print_models(models_payload, current_model)
-        print()
-    except requests.RequestException as e:
-        print_error(f"impossible de récupérer la liste des modèles ({e})")
-        print()
-
-    print(rgb(MUTED, "Tape ton message, ou /help pour la liste des commandes.\n"))
-
-    while True:
-        try:
-            user_input = input(rgb(USER_COLOR, "vous", bold=True) + rgb(MUTED, " ›  "))
-        except (EOFError, KeyboardInterrupt):
-            print()
-            break
-
-        user_input = user_input.strip()
-        if not user_input:
-            continue
-
-        if user_input.startswith("/"):
-            cmd, *rest = user_input[1:].split(maxsplit=1)
-            arg = rest[0].strip() if rest else ""
-            cmd = cmd.lower()
-
-            if cmd in ("quit", "exit"):
-                break
-            elif cmd == "help":
-                print(rgb(MUTED, HELP_TEXT))
-            elif cmd == "clear":
-                sys.stdout.write("\033[H\033[J")
-                sys.stdout.flush()
-            elif cmd == "status":
-                print_status_panel(url, api_key, connected, models_loaded)
-            elif cmd == "save":
-                if not transcript:
-                    print(rgb(MUTED, "  rien à enregistrer pour l'instant."))
-                else:
-                    path = save_transcript(transcript, arg or None)
-                    print(rgb(ACCENT, f"→ conversation enregistrée dans {path}"))
-            elif cmd == "models":
-                try:
-                    models_payload = client.list_models()
-                    print_models(models_payload, current_model)
-                except requests.RequestException as e:
-                    print_error(f"requête échouée ({e})")
-            elif cmd == "model":
-                if not arg:
-                    current_model = select_model_interactively(models_payload, current_model)
-                else:
-                    resolved = resolve_model_choice(arg, models_payload.get("models", [])) or arg
-                    current_model = resolved
-                    print(rgb(ACCENT, f"→ modèle changé pour '{resolved}'"))
-            else:
-                print_error(f"commande inconnue : /{cmd}")
-            continue
-
-        transcript.append({"role": "user", "text": user_input})
-
-        start_time = time.perf_counter()
-        anim = OctopusAnimation(
-            FRAMES_THINKING, label="Opsiom réfléchit", interval=0.2,
-            dynamic=lambda: f"  {time.perf_counter() - start_time:0.1f}s",
-        )
-        anim.start()
-        try:
-            result = client.chat(user_input, model=current_model)
-        except KeyboardInterrupt:
-            anim.stop()
-            print(rgb(MUTED, "  (requête annulée — le serveur continue peut-être de calculer en arrière-plan)"))
-            continue
-        except requests.RequestException as e:
-            anim.stop()
-            show_error_animation()
-            print_error(f"la requête a échoué ({e})")
-            continue
-        anim.stop()
-        elapsed_ms = int((time.perf_counter() - start_time) * 1000)
-
-        flash_sparkle()
-        response_text = result.get("response", "(réponse vide)")
-        used_model = result.get("model", current_model or "?")
-        print_assistant_message(response_text, used_model, elapsed_ms)
-        print_separator()
-        transcript.append({"role": "assistant", "text": response_text, "model": used_model, "elapsed_ms": elapsed_ms})
-
-    save_history()
-
-
-# ----------------------------------------------------------------------------
-# Point d'entrée
-# ----------------------------------------------------------------------------
-
-def main():
-    parser = argparse.ArgumentParser(prog="opsiom", description="CLI de chat pour Opsiom")
-    parser.add_argument("--url", default=None, help="URL du serveur Opsiom (sinon config/prompt)")
-    parser.add_argument("--api-key", default=None, help="clé API si le serveur en exige une")
-    parser.add_argument("--configure", action="store_true", help="reconfigure l'URL/clé et les réenregistre")
-    parser.add_argument("--no-animation", action="store_true", help="désactive l'animation d'intro")
-    parser.add_argument("--version", action="version", version=f"opsiom-cli {VERSION}")
-    args = parser.parse_args()
-
-    if not args.no_animation:
-        print_intro_animation()
-    else:
-        print(gradient_block(TITLE))
-        print()
-
-    url, api_key = resolve_settings(args)
-    if not url:
-        print_error("aucune URL configurée, abandon.")
-        sys.exit(1)
-
-    client = OpsiomClient(url, api_key=api_key)
-    run_chat(client, url, api_key)
-    print(rgb(MUTED, "\nÀ bientôt.\n"))
-
-
-if __name__ == "__main__":
-    main()