opsiom-cli 1.0.0__py3-none-any.whl

opsiom_cli/__init__.py

@@ -0,0 +1,4 @@
+from .cli import VERSION
+
+__all__ = ["VERSION"]
+__version__ = VERSION

opsiom_cli/cli.py

@@ -0,0 +1,644 @@
+#!/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)
+
+VERSION = "1.0.0"
+CONFIG_PATH = Path.home() / ".config" / "opsiom" / "config.json"
+
+
+# ----------------------------------------------------------------------------
+# 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   /  /",
+    "             `._\\  |  /_.'",
+]
+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):
+        self.frames = frames
+        self.label = label
+        self.interval = interval
+        self.loop = loop
+        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 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:
+                sys.stdout.write(rgb(ACCENT, f"  {self.label}{next(dots)}") + "\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
+  /clear            efface l'écran
+  /help             affiche cette aide
+  /quit, /exit      quitte le CLI
+"""
+
+
+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):
+    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 == "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
+
+        anim = OctopusAnimation(FRAMES_THINKING, label="Opsiom réfléchit", interval=0.2)
+        anim.start()
+        start_time = time.perf_counter()
+        try:
+            result = client.chat(user_input, model=current_model)
+        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()
+
+
+# ----------------------------------------------------------------------------
+# 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()

opsiom_cli-1.0.0.dist-info/METADATA

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: opsiom-cli
+Version: 1.0.0
+Summary: CLI de chat pour Opsiom, l'assistant IA francophone.
+Author-email: Ton nom <toi@example.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ton-compte/opsiom-cli
+Keywords: opsiom,cli,chatbot,ia
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31
+
+# Opsiom CLI
+
+Interface en ligne de commande pour discuter avec Opsiom, l'assistant IA
+francophone — avec une mascotte poulpe animée et un thème violet/rose/rouge.
+
+## Installation
+
+```bash
+pip install opsiom-cli
+```
+
+(ou, en isolant proprement l'outil : `pipx install opsiom-cli`)
+
+## Utilisation
+
+```bash
+opsiom
+```
+
+Au premier lancement, le CLI te demande l'URL du serveur Opsiom (et une
+éventuelle clé API) puis les enregistre dans `~/.config/opsiom/config.json`.
+**Ce paquet ne contient aucune URL de serveur codée en dur** — il te faut
+l'URL et, si le serveur en exige une, la clé API fournie par la personne qui
+héberge l'instance à laquelle tu veux te connecter.
+
+Alternative sans fichier de config :
+
+```bash
+opsiom --url https://xxxx.ngrok-free.dev --api-key ta_cle
+```
+
+Reconfigurer :
+
+```bash
+opsiom --configure
+```
+
+## Commandes du chat
+
+- `/model` — menu numéroté pour choisir le modèle
+- `/model <id|numéro>` — change directement de modèle
+- `/models` — liste les modèles disponibles
+- `/status` — réaffiche le panneau de connexion
+- `/clear` — efface l'écran
+- `/help` — aide
+- `/quit`, `/exit` — quitte
+
+## Licence
+
+MIT

opsiom_cli-1.0.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+opsiom_cli/__init__.py,sha256=lNmdCs8Kj7aC1UJwSsfk-VfLjSgBbdIN1Brt4IhrvzM,70
+opsiom_cli/cli.py,sha256=aNt4O0WkjNSpxcMtC3rMkYh7Fj0NtD4I17rlZWOWZwk,23727
+opsiom_cli-1.0.0.dist-info/METADATA,sha256=lglVTpMDTRZisi79JPk1RDL6Y8f_tLky1be2NhNuxJc,1603
+opsiom_cli-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+opsiom_cli-1.0.0.dist-info/entry_points.txt,sha256=DmuAEcK58CeDAE7WrO-DddHmWfsBPXHUiRD2CD3ca6Y,47
+opsiom_cli-1.0.0.dist-info/top_level.txt,sha256=2BU4m7Mc8vxCKbZdiLx_RXu5I-Hi6JdGjTnj1i8b_g8,11
+opsiom_cli-1.0.0.dist-info/RECORD,,

opsiom_cli-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

opsiom_cli-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+opsiom = opsiom_cli.cli:main

opsiom_cli-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+opsiom_cli