nemesis-cli 1.0.2__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,3 @@
1
+ """Client terminal NEMESIS — commande `nemesis`."""
2
+
3
+ __version__ = "1.0.2"
@@ -0,0 +1,4 @@
1
+ """`python -m nemesis_cli` — point d'entrée module."""
2
+ from .main import main
3
+
4
+ main()
nemesis_cli/api.py ADDED
@@ -0,0 +1,209 @@
1
+ """Client HTTP vers l'API NEMESIS + auth Supabase (grant password/refresh)."""
2
+ from __future__ import annotations
3
+
4
+ import base64
5
+ import json
6
+ import time
7
+
8
+ import httpx
9
+
10
+ from .config import SUPABASE_ANON_KEY, SUPABASE_URL
11
+
12
+
13
+ class ErreurAPI(Exception):
14
+ """Erreur HTTP/réseau traduite en français pour l'utilisateur."""
15
+
16
+ def __init__(self, message: str, status: int = 0):
17
+ super().__init__(message)
18
+ self.status = status
19
+
20
+
21
+ def _detail(res: httpx.Response) -> str:
22
+ try:
23
+ data = res.json()
24
+ return str(data.get("detail") or data.get("error_description")
25
+ or data.get("msg") or "")
26
+ except Exception:
27
+ return ""
28
+
29
+
30
+ def _traduire(status: int, detail: str = "") -> str:
31
+ if status == 401:
32
+ return "Session expirée ou jeton invalide — relance `nemesis login`."
33
+ if status == 403:
34
+ return detail or ("Accès refusé : compte non invité, suspendu ou "
35
+ "ressource interdite.")
36
+ if status == 404:
37
+ return detail or "Route introuvable — l'API n'est peut-être pas à jour."
38
+ if status == 429:
39
+ return detail or ("Quota de tokens atteint : réessaie demain ou "
40
+ "passe à un plan supérieur (Premium / Ultra).")
41
+ if status >= 500:
42
+ return detail or (f"Erreur serveur ({status}) — l'API est "
43
+ "peut-être en redémarrage, réessaie dans un instant.")
44
+ return detail or f"Erreur HTTP {status}"
45
+
46
+
47
+ def connexion(email: str, mdp: str,
48
+ url_supa: str = SUPABASE_URL,
49
+ cle: str = SUPABASE_ANON_KEY) -> dict:
50
+ """Grant password Supabase → {jeton, refresh, email} pour la config."""
51
+ try:
52
+ res = httpx.post(
53
+ f"{url_supa.rstrip('/')}/auth/v1/token?grant_type=password",
54
+ headers={"apikey": cle},
55
+ json={"email": email, "password": mdp},
56
+ timeout=20,
57
+ )
58
+ except httpx.HTTPError:
59
+ raise ErreurAPI("Serveur d'authentification injoignable — "
60
+ "vérifie ta connexion réseau.")
61
+ if res.status_code == 400:
62
+ raise ErreurAPI("E-mail ou mot de passe incorrect.", 400)
63
+ if res.status_code != 200:
64
+ raise ErreurAPI(_traduire(res.status_code, _detail(res)),
65
+ res.status_code)
66
+ data = res.json()
67
+ return {
68
+ "jeton": data["access_token"],
69
+ "refresh": data.get("refresh_token", ""),
70
+ "email": (data.get("user") or {}).get("email") or email,
71
+ }
72
+
73
+
74
+ def echanger_code_pkce(code: str, code_verifier: str,
75
+ url_supa: str = SUPABASE_URL,
76
+ cle: str = SUPABASE_ANON_KEY) -> dict:
77
+ """Échange un code OAuth PKCE contre une session {jeton, refresh, email}."""
78
+ try:
79
+ res = httpx.post(
80
+ f"{url_supa.rstrip('/')}/auth/v1/token?grant_type=pkce",
81
+ headers={"apikey": cle},
82
+ json={"auth_code": code, "code_verifier": code_verifier},
83
+ timeout=20,
84
+ )
85
+ except httpx.HTTPError:
86
+ raise ErreurAPI("Serveur d'authentification injoignable — "
87
+ "vérifie ta connexion réseau.")
88
+ if res.status_code != 200:
89
+ raise ErreurAPI("Échec de la connexion OAuth — réessaie "
90
+ "`nemesis login --google`.", res.status_code)
91
+ data = res.json()
92
+ return {
93
+ "jeton": data["access_token"],
94
+ "refresh": data.get("refresh_token", ""),
95
+ "email": (data.get("user") or {}).get("email") or "",
96
+ }
97
+
98
+
99
+ def jeton_expire(jeton: str, marge: int = 60) -> bool:
100
+ """True si le JWT expire dans moins de `marge` s — décodage local, sans
101
+ vérification de signature (c'est le serveur qui la vérifie)."""
102
+ try:
103
+ payload = jeton.split(".")[1]
104
+ payload += "=" * (-len(payload) % 4)
105
+ exp = json.loads(base64.urlsafe_b64decode(payload))["exp"]
106
+ return exp < time.time() + marge
107
+ except Exception:
108
+ return False
109
+
110
+
111
+ def rafraichir(refresh: str,
112
+ url_supa: str = SUPABASE_URL,
113
+ cle: str = SUPABASE_ANON_KEY) -> dict:
114
+ """Refresh grant → {jeton, refresh}. Échec = session morte."""
115
+ try:
116
+ res = httpx.post(
117
+ f"{url_supa.rstrip('/')}/auth/v1/token?grant_type=refresh_token",
118
+ headers={"apikey": cle},
119
+ json={"refresh_token": refresh},
120
+ timeout=15,
121
+ )
122
+ except httpx.HTTPError:
123
+ raise ErreurAPI("Impossible de joindre l'authentification — "
124
+ "vérifie ta connexion.")
125
+ if res.status_code != 200:
126
+ raise ErreurAPI("Session expirée — relance `nemesis login`.", 401)
127
+ data = res.json()
128
+ return {"jeton": data["access_token"],
129
+ "refresh": data.get("refresh_token", refresh)}
130
+
131
+
132
+ class API:
133
+ """Client des routes /api/* — Bearer JWT, erreurs traduites."""
134
+
135
+ def __init__(self, url: str, jeton: str = ""):
136
+ self.url = url.rstrip("/")
137
+ self.jeton = jeton
138
+ self.client = httpx.Client(
139
+ timeout=httpx.Timeout(60.0, connect=10.0))
140
+
141
+ def _req(self, methode: str, chemin: str, **kw) -> httpx.Response:
142
+ h = {"Content-Type": "application/json"}
143
+ if self.jeton:
144
+ h["Authorization"] = f"Bearer {self.jeton}"
145
+ try:
146
+ res = self.client.request(
147
+ methode, f"{self.url}{chemin}", headers=h, **kw)
148
+ except httpx.ConnectError:
149
+ raise ErreurAPI(
150
+ f"API injoignable : {self.url}\n"
151
+ "Vérifie l'URL (NEMESIS_API_URL / nemesis login) "
152
+ "et ta connexion.")
153
+ except httpx.HTTPError as e:
154
+ raise ErreurAPI(
155
+ f"Erreur réseau ({e.__class__.__name__}) — réessaie.")
156
+ if res.status_code >= 400:
157
+ raise ErreurAPI(
158
+ _traduire(res.status_code, _detail(res)), res.status_code)
159
+ return res
160
+
161
+ def get(self, chemin: str) -> dict:
162
+ return self._req("GET", chemin).json()
163
+
164
+ def post(self, chemin: str, data: dict) -> dict:
165
+ return self._req("POST", chemin, json=data).json()
166
+
167
+ def soumettre(self, message: str, template: str = "auto",
168
+ contexte: str | None = None) -> str:
169
+ rep = self.post("/api/jobs", {
170
+ "message": message, "template": template, "context": contexte,
171
+ })
172
+ return rep["job_id"]
173
+
174
+ def completions(self, message: str,
175
+ historique: list[dict] | None = None) -> str:
176
+ """POST /v1/chat/completions (format OpenAI) — réponse directe,
177
+ sans job à poller. Pour `nemesis chat "…"`."""
178
+ messages = [
179
+ {"role": m["role"], "content": m["content"]}
180
+ for m in (historique or [])
181
+ if m.get("role") in ("user", "assistant")]
182
+ messages.append({"role": "user", "content": message})
183
+ rep = self.post("/v1/chat/completions",
184
+ {"model": "nemesis", "messages": messages})
185
+ return rep["choices"][0]["message"]["content"]
186
+
187
+ def job(self, job_id: str) -> dict:
188
+ return self.get(f"/api/jobs/{job_id}")
189
+
190
+ def quota(self) -> dict:
191
+ try:
192
+ return self.get("/api/jobs/quota")
193
+ except ErreurAPI:
194
+ return {}
195
+
196
+ def statut(self) -> dict:
197
+ return self.get("/api/user/status")
198
+
199
+ def telecharger(self, chemin_relatif: str) -> tuple[bytes, str]:
200
+ """GET /api/download/{id} → (contenu, nom de fichier)."""
201
+ res = self._req("GET", chemin_relatif)
202
+ nom = "nemesis.pdf"
203
+ cd = res.headers.get("Content-Disposition", "")
204
+ if 'filename="' in cd:
205
+ nom = cd.split('filename="', 1)[1].split('"', 1)[0]
206
+ return res.content, nom
207
+
208
+ def close(self) -> None:
209
+ self.client.close()
Binary file
@@ -0,0 +1,210 @@
1
+ """Commandes slash, garde-fous /file et /save, presse-papiers."""
2
+ from __future__ import annotations
3
+
4
+ import re
5
+ import shlex
6
+ import subprocess
7
+ import sys
8
+ from pathlib import Path
9
+
10
+ from . import ui
11
+
12
+ COMMANDES = {
13
+ "/help": "affiche cette aide",
14
+ "/exit": "quitte le chat (alias : /quit)",
15
+ "/quit": "quitte le chat",
16
+ "/clear": "efface l'écran et remet le contexte à zéro",
17
+ "/file <chemin> [autres…]": "joint des fichiers texte au prochain message",
18
+ "/save [nom]": "enregistre la dernière réponse ou le dernier bloc de code",
19
+ "/copy": "copie le dernier bloc de code dans le presse-papiers",
20
+ "/pdf <titre>": "génère un rapport PDF et le télécharge ici",
21
+ "/history": "affiche les échanges du contexte",
22
+ "/whoami": "affiche compte, plan et quota du mois",
23
+ "/quota": "affiche les tokens restants ce mois-ci",
24
+ "/compact": "réduit le contexte aux 4 derniers échanges",
25
+ }
26
+
27
+ TAILLE_MAX = 200 * 1024 # 200 Ko
28
+ LIGNES_APERTU = 400 # extrait si le fichier est énorme mais accepté
29
+
30
+ CHEMIN_SENSIBLE = re.compile(
31
+ r"(^|[/\\])\.env(\.|$)|\.pem$|id_rsa|\.key$|[/\\]\.ssh|[/\\]\.aws|"
32
+ r"[/\\]\.nemesis|\.pfx$|credentials\.json$", re.IGNORECASE)
33
+
34
+ SECRET_EVIDENT = re.compile(
35
+ r"sk-[A-Za-z0-9_\-]{10,}" # OpenAI/OpenRouter
36
+ r"|sk-ant-[A-Za-z0-9_\-]{10,}" # Anthropic
37
+ r"|xox[baprs]-[A-Za-z0-9\-]{10,}" # Slack
38
+ r"|AKIA[0-9A-Z]{16}" # AWS access key
39
+ r"|gh[pousr]_[A-Za-z0-9]{20,}" # GitHub
40
+ r"|-----BEGIN [A-Z ]*PRIVATE KEY-----"
41
+ r"|service_role['\"\s:=]+[A-Za-z0-9_\-\.]{20,}"
42
+ r"|eyJ[A-Za-z0-9_\-]{10,}\.eyJ[A-Za-z0-9_\-]{10,}") # JWT
43
+
44
+
45
+ def parser_commande(ligne: str) -> tuple[str, list[str]] | None:
46
+ """'/pdf rapport marché' → ('/pdf', ['rapport', 'marché']). None sinon."""
47
+ ligne = ligne.strip()
48
+ if not ligne.startswith("/"):
49
+ return None
50
+ try:
51
+ mots = shlex.split(ligne)
52
+ except ValueError:
53
+ mots = ligne.split()
54
+ if not mots:
55
+ return None
56
+ return mots[0].lower(), mots[1:]
57
+
58
+
59
+ def aide() -> str:
60
+ lignes = ["Commandes :"]
61
+ for cmd, desc in COMMANDES.items():
62
+ lignes.append(f" {cmd:34s} {desc}")
63
+ lignes.append(" Entrée=envoyer · Alt+Maj+Entrée=nouvelle ligne · "
64
+ "Ctrl+C=annule · Ctrl+D=quitte")
65
+ return "\n".join(lignes)
66
+
67
+
68
+ # ───────────────────────────── /file ─────────────────────────────
69
+
70
+ def lire_fichier(chemin: str, confirmer=ui.demander_confirm) -> str | None:
71
+ """Lit un fichier avec garde-fous. Renvoie le bloc de contexte markdown
72
+ ou None si refusé. Lève ValueError avec message français."""
73
+ p = Path(chemin).expanduser()
74
+ if not p.exists():
75
+ raise ValueError(f"Fichier introuvable : {chemin}")
76
+ if not p.is_file():
77
+ raise ValueError(f"Pas un fichier : {chemin}")
78
+
79
+ rel = str(p)
80
+ if CHEMIN_SENSIBLE.search(rel) or CHEMIN_SENSIBLE.search(p.name):
81
+ if not confirmer(f"⚠ {p.name} est un chemin sensible "
82
+ f"(clés/env). L'envoyer quand même ?"):
83
+ raise ValueError(f"{p.name} : envoi refusé (chemin sensible).")
84
+
85
+ taille = p.stat().st_size
86
+ if taille > TAILLE_MAX:
87
+ raise ValueError(
88
+ f"{p.name} fait {taille // 1024} Ko (max 200 Ko). "
89
+ "Coupe-le ou résume-le d'abord.")
90
+ try:
91
+ texte = p.read_text(encoding="utf-8")
92
+ except UnicodeDecodeError:
93
+ raise ValueError(f"{p.name} n'est pas du texte lisible "
94
+ "(binaire ?).")
95
+
96
+ if SECRET_EVIDENT.search(texte):
97
+ if not confirmer(f"⚠ {p.name} semble contenir des secrets "
98
+ f"(clés API, tokens…). Envoyer quand même ?"):
99
+ raise ValueError(f"{p.name} : envoi refusé (secret détecté).")
100
+
101
+ lignes = texte.splitlines()
102
+ extrait = texte
103
+ if len(lignes) > LIGNES_APERTU:
104
+ extrait = "\n".join(lignes[:LIGNES_APERTU])
105
+ extrait += f"\n… ({len(lignes) - LIGNES_APERTU} lignes restantes)"
106
+ ui.info(f"📎 {p.name} ({len(lignes)} lignes) joint")
107
+ return f"### Fichier `{p.name}`\n```\n{extrait}\n```"
108
+
109
+
110
+ def jointures(chemins: list[str], confirmer=ui.demander_confirm) -> str:
111
+ """/file a b c → un bloc de contexte markdown. Erreurs collectées."""
112
+ blocs, erreurs = [], []
113
+ for c in chemins:
114
+ try:
115
+ blocs.append(lire_fichier(c, confirmer))
116
+ except ValueError as e:
117
+ erreurs.append(str(e))
118
+ for e in erreurs:
119
+ ui.afficher_erreur(ValueError(e))
120
+ return "\n\n".join(b for b in blocs if b)
121
+
122
+
123
+ # ───────────────────────────── /save & /copy ─────────────────────────────
124
+
125
+ EXTS = {"python": ".py", "py": ".py", "javascript": ".js", "js": ".js",
126
+ "typescript": ".ts", "ts": ".ts", "html": ".html", "css": ".css",
127
+ "bash": ".sh", "sh": ".sh", "json": ".json", "sql": ".sql",
128
+ "yaml": ".yaml", "yml": ".yml", "go": ".go", "rust": ".rs",
129
+ "java": ".java", "c": ".c", "cpp": ".cpp"}
130
+
131
+
132
+ def dernier_bloc_code(texte: str) -> tuple[str, str] | None:
133
+ """Extrait le dernier ```lang … ``` → (lang, code)."""
134
+ blocs = re.findall(r"```(\w*)\n(.*?)```", texte, re.DOTALL)
135
+ if not blocs:
136
+ return None
137
+ return blocs[-1]
138
+
139
+
140
+ def nom_defaut(texte: str, base: str = "nemesis") -> str:
141
+ bloc = dernier_bloc_code(texte)
142
+ if bloc:
143
+ return base + EXTS.get(bloc[0].lower(), ".txt")
144
+ return base + ".md"
145
+
146
+
147
+ def sauvegarder(contenu: str, nom: str,
148
+ confirmer=ui.demander_confirm) -> Path | None:
149
+ """Écrit `contenu` dans `nom` — jamais hors du dossier courant ni
150
+ écrasement sans confirmation. Renvoie le chemin absolu."""
151
+ dest = Path(nom).expanduser()
152
+ if not dest.is_absolute():
153
+ dest = (Path.cwd() / dest).resolve()
154
+ else:
155
+ dest = dest.resolve()
156
+
157
+ if Path.cwd() not in dest.parents and dest != Path.cwd():
158
+ if not confirmer(f"⚠ {dest} est hors du dossier courant "
159
+ f"({Path.cwd()}). Écrire quand même ?"):
160
+ ui.avertir("Enregistrement annulé (hors dossier courant).")
161
+ return None
162
+ if dest.exists():
163
+ if not confirmer(f"⚠ {dest.name} existe déjà. Écraser ?"):
164
+ ui.avertir("Enregistrement annulé.")
165
+ return None
166
+ dest.parent.mkdir(parents=True, exist_ok=True)
167
+ dest.write_text(contenu, encoding="utf-8")
168
+ ui.info(f"✓ Enregistré : {dest}")
169
+ return dest
170
+
171
+
172
+ def sauvegarder_bytes(data: bytes, nom: str,
173
+ confirmer=ui.demander_confirm) -> Path | None:
174
+ """Idem sauvegarder() mais pour du binaire (PDF téléchargé)."""
175
+ dest = Path(nom)
176
+ if not dest.is_absolute():
177
+ dest = (Path.cwd() / dest).resolve()
178
+ if Path.cwd() not in dest.parents and dest != Path.cwd():
179
+ if not confirmer(f"⚠ {dest} est hors du dossier courant. "
180
+ "Écrire quand même ?"):
181
+ ui.avertir("Enregistrement annulé.")
182
+ return None
183
+ if dest.exists() and not confirmer(f"⚠ {dest.name} existe. Écraser ?"):
184
+ ui.avertir("Enregistrement annulé.")
185
+ return None
186
+ dest.parent.mkdir(parents=True, exist_ok=True)
187
+ dest.write_bytes(data)
188
+ ui.info(f"✓ Enregistré : {dest}")
189
+ return dest
190
+
191
+
192
+ def copier(texte: str) -> bool:
193
+ """Copie dans le presse-papiers (clip.exe / pbcopy / xclip / wl-copy)."""
194
+ essais = []
195
+ if sys.platform.startswith("win"):
196
+ essais = [["clip"]]
197
+ elif sys.platform == "darwin":
198
+ essais = [["pbcopy"]]
199
+ else:
200
+ essais = [["wl-copy"], ["xclip", "-selection", "clipboard"],
201
+ ["xsel", "-b"]]
202
+ for cmd in essais:
203
+ try:
204
+ subprocess.run(cmd, input=texte.encode("utf-8"),
205
+ check=True, capture_output=True, timeout=5)
206
+ return True
207
+ except (FileNotFoundError, subprocess.CalledProcessError,
208
+ subprocess.TimeoutExpired):
209
+ continue
210
+ return False
nemesis_cli/config.py ADDED
@@ -0,0 +1,61 @@
1
+ """Configuration du CLI : ~/.nemesis/config.toml (chmod 600) + variables d'env.
2
+
3
+ Priorité : NEMESIS_API_URL / NEMESIS_TOKEN > config.toml > défauts.
4
+ Le .env du backend n'est JAMAIS chargé ici (sauf mode --local explicite).
5
+ """
6
+ from __future__ import annotations
7
+
8
+ import os
9
+ import stat
10
+ import tomllib
11
+ from pathlib import Path
12
+
13
+ DOSSIER = Path.home() / ".nemesis"
14
+ FICHIER = DOSSIER / "config.toml"
15
+ HISTORIQUE = DOSSIER / "historique"
16
+
17
+ # Instance publique par défaut. La clé anon Supabase est « publishable » :
18
+ # elle est déjà servie à tous les navigateurs par le frontend — pas un secret.
19
+ API_URL_DEFAUT = "https://nemesis-ia-production-d93c.up.railway.app"
20
+ SUPABASE_URL = "https://zxjlmbftwnsabupkcpto.supabase.co"
21
+ SUPABASE_ANON_KEY = "sb_publishable_5DVn_Ztn-ZBMH2z1mNejiw_-XsKNFDm"
22
+
23
+
24
+ def charger() -> dict:
25
+ """Renvoie {url_api, jeton, refresh, email} fusionné fichier + env."""
26
+ cfg = {"url_api": API_URL_DEFAUT, "jeton": "", "refresh": "", "email": ""}
27
+ if FICHIER.exists():
28
+ try:
29
+ cfg.update({k: v for k, v in tomllib.loads(
30
+ FICHIER.read_text(encoding="utf-8")).items() if isinstance(v, str)})
31
+ except Exception:
32
+ pass # config corrompue → défauts
33
+ if os.getenv("NEMESIS_API_URL"):
34
+ cfg["url_api"] = os.environ["NEMESIS_API_URL"]
35
+ if os.getenv("NEMESIS_TOKEN"):
36
+ cfg["jeton"] = os.environ["NEMESIS_TOKEN"]
37
+ cfg["url_api"] = cfg["url_api"].rstrip("/")
38
+ return cfg
39
+
40
+
41
+ def sauvegarder(cfg: dict) -> None:
42
+ """Écrit config.toml en 600 — le jeton n'est jamais affiché ni logué."""
43
+ DOSSIER.mkdir(parents=True, exist_ok=True)
44
+ lignes = []
45
+ for k, v in cfg.items():
46
+ if v:
47
+ v = str(v).replace("\\", "\\\\").replace('"', '\\"')
48
+ lignes.append(f'{k} = "{v}"')
49
+ FICHIER.write_text("\n".join(lignes) + "\n", encoding="utf-8")
50
+ try:
51
+ os.chmod(FICHIER, stat.S_IRUSR | stat.S_IWUSR)
52
+ except OSError:
53
+ pass # Windows : les ACL du profil utilisateur s'appliquent déjà
54
+
55
+
56
+ def effacer() -> None:
57
+ """logout : supprime le jeton, conserve l'URL de l'API."""
58
+ cfg = charger()
59
+ for cle in ("jeton", "refresh", "email"):
60
+ cfg.pop(cle, None)
61
+ sauvegarder(cfg)
nemesis_cli/main.py ADDED
@@ -0,0 +1,589 @@
1
+ """nemesis — client terminal NEMESIS.
2
+
3
+ nemesis chat interactif
4
+ nemesis "question" une réponse, puis fin (markdown brut si pipe)
5
+ nemesis -p "question" idem
6
+ nemesis --code "…" génère du code, propose [s]ave/[c]opy/[r]egen/[q]
7
+ nemesis --local orchestrateur CrewAI en direct (dev, hors quotas)
8
+ nemesis chat "question" réponse directe (/v1/chat/completions)
9
+ nemesis doc "Sujet" --pages N génère et télécharge un PDF
10
+ nemesis login|logout|whoami|quota
11
+ """
12
+ from __future__ import annotations
13
+
14
+ import getpass
15
+ import os
16
+ import sys
17
+ import threading
18
+ import time
19
+ from pathlib import Path
20
+
21
+ import click
22
+
23
+ from . import api as apimod
24
+ from . import commandes, config, ui
25
+ from . import __version__
26
+
27
+ BACKEND_DIR = Path(__file__).resolve().parent.parent # backend/
28
+ CONTEXT_MAX = 10
29
+
30
+
31
+ # ─────────────────────────── auth ───────────────────────────
32
+
33
+ def _login() -> None:
34
+ """Connexion par clé personnelle `nem_…` — générée sur le site,
35
+ page Terminal (affichée une seule fois)."""
36
+ ui.afficher_banniere(__version__)
37
+ ui.panneau(
38
+ "Génère ta clé sur le site (Outils → Terminal) "
39
+ "puis colle-la ici.", "Connexion par clé")
40
+ cle = getpass.getpass("Clé personnelle : ").strip()
41
+ if not cle.startswith("nem_"):
42
+ ui.afficher_erreur(apimod.ErreurAPI(
43
+ "Format de clé invalide — elle commence par « nem_ ». "
44
+ "Génère-la sur le site, page Terminal."))
45
+ sys.exit(1)
46
+ cfg = config.charger()
47
+ cfg.update({"jeton": cle, "refresh": "", "email": ""})
48
+ config.sauvegarder(cfg)
49
+ try:
50
+ api = _client(cfg, rafraichir_si_besoin=False)
51
+ st = api.statut()
52
+ email = st.get("email", "")
53
+ cfg["email"] = email
54
+ config.sauvegarder(cfg)
55
+ except apimod.ErreurAPI as e:
56
+ config.effacer()
57
+ ui.afficher_erreur(apimod.ErreurAPI(
58
+ f"Clé refusée : {e}\nRégénère-la sur le site "
59
+ "(l'ancienne est révoquée)."))
60
+ sys.exit(1)
61
+ ui.afficher_succes(
62
+ f"✓ Connecté en tant que {email or 'ton compte'} — "
63
+ f"clé stockée dans {config.FICHIER} (jamais affichée).")
64
+
65
+
66
+ def _login_email() -> None:
67
+ ui.afficher_banniere(__version__)
68
+ ui.panneau("Connecte-toi avec l'e-mail et le mot de passe "
69
+ "de ton compte NEMESIS.", "Connexion e-mail")
70
+ email = click.prompt("E-mail").strip()
71
+ mdp = getpass.getpass("Mot de passe : ")
72
+ try:
73
+ sess = apimod.connexion(email, mdp)
74
+ except apimod.ErreurAPI as e:
75
+ ui.afficher_erreur(e)
76
+ sys.exit(1)
77
+ cfg = config.charger()
78
+ cfg.update(sess)
79
+ config.sauvegarder(cfg)
80
+ ui.afficher_succes(
81
+ f"✓ Connecté en tant que {sess['email']} — jeton stocké "
82
+ f"dans {config.FICHIER} (jamais affiché).")
83
+
84
+
85
+ def _login_google() -> None:
86
+ """OAuth Google : ouvre le navigateur, callback local PKCE."""
87
+ import base64
88
+ import hashlib
89
+ import secrets
90
+ import threading
91
+ import urllib.parse as up
92
+ import webbrowser
93
+ from http.server import BaseHTTPRequestHandler, HTTPServer
94
+
95
+ ui.afficher_banniere(__version__)
96
+ verifier = secrets.token_urlsafe(64)
97
+ challenge = base64.urlsafe_b64encode(
98
+ hashlib.sha256(verifier.encode()).digest()).rstrip(b"=").decode()
99
+
100
+ recu: dict = {}
101
+
102
+ class Handler(BaseHTTPRequestHandler):
103
+ def do_GET(self):
104
+ params = up.parse_qs(up.urlparse(self.path).query)
105
+ if "code" in params:
106
+ recu["code"] = params["code"][0]
107
+ body = b"<h2>Connexion NEMESIS reussie - tu peux fermer cet onglet.</h2>"
108
+ else:
109
+ recu["erreur"] = params.get("error_description",
110
+ params.get("error", ["?"]))[0]
111
+ body = b"<h2>Echec de connexion.</h2>"
112
+ self.send_response(200)
113
+ self.send_header("Content-Type", "text/html; charset=utf-8")
114
+ self.end_headers()
115
+ self.wfile.write(body)
116
+
117
+ def log_message(self, *a): # silence
118
+ pass
119
+
120
+ serveur = HTTPServer(("127.0.0.1", 0), Handler)
121
+ port = serveur.server_port
122
+ threading.Thread(target=serveur.handle_request, daemon=True).start()
123
+
124
+ redirect = f"http://127.0.0.1:{port}/callback"
125
+ params = up.urlencode({
126
+ "provider": "google",
127
+ "redirect_to": redirect,
128
+ "code_challenge": challenge,
129
+ "code_challenge_method": "s256",
130
+ })
131
+ url = f"{config.SUPABASE_URL}/auth/v1/authorize?{params}"
132
+ ui.panneau("Ouverture du navigateur pour Google…",
133
+ "Connexion Google")
134
+ webbrowser.open(url)
135
+ ui.console.print("[dim]Si rien ne s'ouvre : " + url[:80] + "…[/dim]")
136
+
137
+ fin = time.time() + 120
138
+ while "code" not in recu and "erreur" not in recu and time.time() < fin:
139
+ time.sleep(0.3)
140
+ serveur.server_close()
141
+
142
+ if "erreur" in recu:
143
+ ui.afficher_erreur(apimod.ErreurAPI(
144
+ f"OAuth refusé : {recu['erreur']}\n"
145
+ "Ajoute http://127.0.0.1:*/callback dans Supabase → "
146
+ "Authentication → URL Configuration → Redirect URLs."))
147
+ sys.exit(1)
148
+ if "code" not in recu:
149
+ ui.afficher_erreur(apimod.ErreurAPI(
150
+ "Délai dépassé (2 min) — réessaie `nemesis login --google`."))
151
+ sys.exit(1)
152
+
153
+ try:
154
+ sess = apimod.echanger_code_pkce(recu["code"], verifier)
155
+ except apimod.ErreurAPI as e:
156
+ ui.afficher_erreur(e)
157
+ sys.exit(1)
158
+ cfg = config.charger()
159
+ cfg.update(sess)
160
+ config.sauvegarder(cfg)
161
+ ui.afficher_succes(
162
+ f"✓ Connecté en tant que {sess['email']} — jeton stocké "
163
+ f"dans {config.FICHIER}.")
164
+
165
+
166
+ def _logout() -> None:
167
+ config.effacer()
168
+ ui.info("✓ Déconnecté — jeton local supprimé.")
169
+
170
+
171
+ def _client(cfg: dict, rafraichir_si_besoin: bool = True) -> apimod.API:
172
+ """API prête à l'emploi ; rafraîchit le JWT via le refresh token."""
173
+ jeton = cfg.get("jeton", "")
174
+ if not jeton:
175
+ raise apimod.ErreurAPI(
176
+ "Pas de session — lance `nemesis login` d'abord.")
177
+ if apimod.jeton_expire(jeton) and rafraichir_si_besoin and cfg.get("refresh"):
178
+ try:
179
+ sess = apimod.rafraichir(cfg["refresh"])
180
+ cfg.update(sess)
181
+ config.sauvegarder(cfg)
182
+ jeton = cfg["jeton"]
183
+ except apimod.ErreurAPI:
184
+ raise apimod.ErreurAPI(
185
+ "Session expirée — relance `nemesis login`.", 401)
186
+ return apimod.API(cfg["url_api"], jeton)
187
+
188
+
189
+ def _telecharger_fichier(api: apimod.API, f: dict | None) -> None:
190
+ """Télécharge le fichier produit par un job (lien signé 10 min)."""
191
+ if f and f.get("id"):
192
+ lien = api.post(f"/api/documents/{f['id']}/lien", {})
193
+ data, nom = api.telecharger(lien["url"])
194
+ commandes.sauvegarder_bytes(data, nom)
195
+ elif f and f.get("url"):
196
+ data, nom = api.telecharger(f["url"])
197
+ commandes.sauvegarder_bytes(data, nom)
198
+ else:
199
+ ui.avertir("Job terminé sans fichier joint.")
200
+
201
+
202
+ def _doc(api: apimod.API, mots: list[str], timeout: int) -> None:
203
+ """`nemesis doc "Sujet" [--pages N]` — génère et télécharge un PDF."""
204
+ pages = None
205
+ sujets = []
206
+ it = iter(mots[1:])
207
+ for m in it:
208
+ if m == "--pages":
209
+ try:
210
+ pages = int(next(it))
211
+ except (StopIteration, ValueError):
212
+ ui.avertir("`--pages` attend un nombre (ex : --pages 3).")
213
+ return
214
+ else:
215
+ sujets.append(m)
216
+ sujet = " ".join(sujets).strip()
217
+ if not sujet:
218
+ ui.avertir('Usage : nemesis doc "Sujet" [--pages N]')
219
+ return
220
+ demande = f"Génère un document PDF intitulé « {sujet} »"
221
+ demande += f" en {pages} pages." if pages else "."
222
+ job_id = api.soumettre(demande)
223
+ job = ui.suivre_job(api, job_id, timeout=timeout,
224
+ interactif=ui.est_interactif())
225
+ _telecharger_fichier(api, job.get("fichier"))
226
+
227
+
228
+ def _whoami(api: apimod.API) -> None:
229
+ st = api.statut()
230
+ q = api.quota()
231
+ plan = st.get("plan", "?")
232
+ ui.console.print(f" Compte : [cyan]{st.get('email', '?')}[/cyan]")
233
+ ui.console.print(f" Plan : [cyan]{plan}[/cyan]")
234
+ _afficher_quota_detail(q)
235
+
236
+
237
+ def _afficher_quota_detail(q: dict) -> None:
238
+ if q.get("unlimited"):
239
+ ui.console.print(" Quota : [green]illimité[/green]")
240
+ elif q:
241
+ restants, limite = q.get("remaining", "?"), q.get("limit", "?")
242
+ ui.console.print(
243
+ f" Quota : {restants} tokens restants sur {limite}/mois")
244
+
245
+
246
+ # ─────────────────────────── exécution ───────────────────────────
247
+
248
+ def _contexte_texte(contexte: list[tuple[str, str]]) -> str | None:
249
+ """Les 10 derniers échanges en texte brut pour l'API."""
250
+ if not contexte:
251
+ return None
252
+ lignes = []
253
+ for role, txt in contexte:
254
+ prefixe = "Utilisateur" if role == "user" else "NEMESIS"
255
+ lignes.append(f"{prefixe} : {txt}")
256
+ return "\n\n".join(lignes)
257
+
258
+
259
+ def _executer_local(message: str, contexte: str | None) -> dict:
260
+ """Mode --local : appelle l'orchestrateur CrewAI directement."""
261
+ sys.path.insert(0, str(BACKEND_DIR))
262
+ os.chdir(BACKEND_DIR)
263
+ from dotenv import load_dotenv # backend seulement
264
+ load_dotenv(BACKEND_DIR / ".env")
265
+ from cli import executer_job # backend/cli.py — l'orchestrateur
266
+
267
+ resultat: dict = {}
268
+
269
+ def run() -> None:
270
+ resultat["job"] = executer_job(
271
+ template="auto", sujet=message, contexte=contexte,
272
+ user_email="cli-local", compteur={})
273
+
274
+ t = threading.Thread(target=run, daemon=True)
275
+ t.start()
276
+ with ui.console.status("[cyan]NEMESIS réfléchit…[/cyan]"):
277
+ while t.is_alive():
278
+ t.join(timeout=0.2)
279
+ if resultat.get("job") is None:
280
+ raise apimod.ErreurAPI("Le job local n'a rien renvoyé.")
281
+ j = resultat["job"]
282
+ if j.status == "failed":
283
+ raise apimod.ErreurAPI(j.error or "Job local échoué.")
284
+ return {"result": j.result, "sources": j.sources, "titre": j.titre,
285
+ "fichier": j.fichier}
286
+
287
+
288
+ def _envoyer(api: apimod.API | None, message: str, contexte: str | None,
289
+ timeout: int, local: bool) -> dict:
290
+ """Soumet la demande et attend le résultat. Ctrl+C = annulation locale."""
291
+ try:
292
+ if local:
293
+ return _executer_local(message, contexte)
294
+ job_id = api.soumettre(message, contexte=contexte)
295
+ return ui.suivre_job(api, job_id, timeout=timeout,
296
+ interactif=ui.est_interactif())
297
+ except KeyboardInterrupt:
298
+ ui.avertir("Annulé — le job continue côté serveur, "
299
+ "la réponse arrivera dans l'app web.")
300
+ return {}
301
+
302
+
303
+ def _afficher_job(job: dict) -> None:
304
+ if not job:
305
+ return
306
+ ui.afficher_reponse(job.get("result") or "(réponse vide)",
307
+ job.get("sources"), job.get("titre"))
308
+
309
+
310
+ # ─────────────────────────── mode code ───────────────────────────
311
+
312
+ def _mode_code(api: apimod.API, demande: str, timeout: int,
313
+ local: bool) -> None:
314
+ while True:
315
+ job = _envoyer(api, f"Génère le code demandé, sans exécution : {demande}",
316
+ None, timeout, local)
317
+ if not job:
318
+ return
319
+ texte = job.get("result") or ""
320
+ _afficher_job(job)
321
+ if not ui.est_interactif():
322
+ return
323
+ choix = ui.console.input(
324
+ "[dim][s]auvegarder · [c]opier · [r]égénérer · [q]uitter[/dim] "
325
+ ).strip().lower()
326
+ if choix == "s":
327
+ nom_def = commandes.nom_defaut(texte)
328
+ nom = ui.console.input(
329
+ f"[dim]Nom du fichier ({nom_def}) :[/dim] ").strip() or nom_def
330
+ bloc = commandes.dernier_bloc_code(texte)
331
+ commandes.sauvegarder(bloc[1] if bloc else texte, nom)
332
+ elif choix == "c":
333
+ bloc = commandes.dernier_bloc_code(texte)
334
+ if bloc and commandes.copier(bloc[1]):
335
+ ui.info("✓ Code copié dans le presse-papiers.")
336
+ else:
337
+ ui.avertir("Presse-papiers indisponible sur ce système.")
338
+ elif choix == "r":
339
+ continue
340
+ else:
341
+ return
342
+
343
+
344
+ # ─────────────────────────── chat interactif ───────────────────────────
345
+
346
+ def _boucle_chat(api: apimod.API | None, timeout: int, local: bool) -> None:
347
+ from prompt_toolkit import PromptSession
348
+ from prompt_toolkit.completion import Completer, Completion
349
+ from prompt_toolkit.key_binding import KeyBindings
350
+ from prompt_toolkit.history import FileHistory
351
+
352
+ config.DOSSIER.mkdir(parents=True, exist_ok=True)
353
+
354
+ class SlashCompleter(Completer):
355
+ def get_completions(self, document, complete_event):
356
+ if document.text.startswith("/"):
357
+ for c in commandes.COMMANDES:
358
+ cmd = c.split()[0]
359
+ if cmd.startswith(document.text.split()[0]):
360
+ yield Completion(cmd, start_position=-len(document.text))
361
+
362
+ kb = KeyBindings()
363
+
364
+ @kb.add("escape", "enter") # Alt+Entrée = nouvelle ligne
365
+ def _(event):
366
+ event.current_buffer.insert_text("\n")
367
+
368
+ session = PromptSession(history=FileHistory(str(config.HISTORIQUE)),
369
+ completer=SlashCompleter(), key_bindings=kb)
370
+ contexte: list[tuple[str, str]] = []
371
+ jointure: str | None = None
372
+ derniere_reponse = ""
373
+
374
+ while True:
375
+ try:
376
+ ligne = session.prompt("❯ ").strip()
377
+ except KeyboardInterrupt:
378
+ continue
379
+ except EOFError:
380
+ ui.console.print("[dim]À bientôt.[/dim]")
381
+ return
382
+ if not ligne:
383
+ continue
384
+
385
+ parsed = commandes.parser_commande(ligne)
386
+ if parsed:
387
+ cmd, args = parsed
388
+ if cmd in ("/exit", "/quit"):
389
+ ui.console.print("[dim]À bientôt.[/dim]")
390
+ return
391
+ if cmd == "/help":
392
+ ui.console.print(commandes.aide())
393
+ continue
394
+ if cmd == "/clear":
395
+ contexte.clear()
396
+ ui.console.clear()
397
+ ui.info("✓ Contexte remis à zéro.")
398
+ continue
399
+ if cmd == "/file":
400
+ if not args:
401
+ ui.avertir("Usage : /file <chemin> [autres…]")
402
+ continue
403
+ bloc = commandes.jointures(args)
404
+ if bloc:
405
+ jointure = bloc
406
+ continue
407
+ if cmd == "/save":
408
+ if not derniere_reponse:
409
+ ui.avertir("Rien à enregistrer.")
410
+ continue
411
+ nom = args[0] if args else commandes.nom_defaut(derniere_reponse)
412
+ bloc = commandes.dernier_bloc_code(derniere_reponse)
413
+ contenu = bloc[1] if bloc and not args else derniere_reponse
414
+ commandes.sauvegarder(contenu, nom)
415
+ continue
416
+ if cmd == "/copy":
417
+ bloc = commandes.dernier_bloc_code(derniere_reponse)
418
+ if bloc and commandes.copier(bloc[1]):
419
+ ui.info("✓ Copié.")
420
+ else:
421
+ ui.avertir("Pas de bloc de code ou presse-papiers absent.")
422
+ continue
423
+ if cmd == "/pdf":
424
+ titre = " ".join(args) or "rapport"
425
+ if local:
426
+ ui.avertir("/pdf utilise l'API — mode local indisponible ici.")
427
+ continue
428
+ try:
429
+ job_id = api.soumettre(
430
+ f"Rédige un rapport PDF détaillé intitulé « {titre} ».",
431
+ contexte=_contexte_texte(contexte))
432
+ job = ui.suivre_job(api, job_id, timeout=timeout,
433
+ interactif=ui.est_interactif())
434
+ _telecharger_fichier(api, job.get("fichier"))
435
+ except (apimod.ErreurAPI, KeyboardInterrupt) as e:
436
+ if isinstance(e, apimod.ErreurAPI):
437
+ ui.afficher_erreur(e)
438
+ else:
439
+ ui.avertir("Annulé.")
440
+ continue
441
+ if cmd == "/history":
442
+ for role, txt in contexte:
443
+ if role == "user":
444
+ ui.console.print(
445
+ f"[bold blue]Vous[/bold blue] "
446
+ f"[dim]{txt[:120]}[/dim]")
447
+ else:
448
+ ui.console.print(
449
+ f"[bold cyan]NEMESIS[/bold cyan] "
450
+ f"[dim]{txt[:120]}[/dim]")
451
+ continue
452
+ if cmd == "/whoami":
453
+ try:
454
+ _whoami(api)
455
+ except apimod.ErreurAPI as e:
456
+ ui.afficher_erreur(e)
457
+ continue
458
+ if cmd == "/quota":
459
+ ui.afficher_quota(api.quota())
460
+ continue
461
+ if cmd == "/compact":
462
+ contexte[:] = contexte[-4:]
463
+ ui.info("✓ Contexte compacté (4 derniers échanges).")
464
+ continue
465
+ ui.avertir(f"Commande inconnue : {cmd} — /help pour la liste.")
466
+ continue
467
+
468
+ # message normal
469
+ message = ligne
470
+ if jointure:
471
+ message = f"{ligne}\n\n{jointure}"
472
+ jointure = None
473
+ try:
474
+ job = _envoyer(api, message, _contexte_texte(contexte),
475
+ timeout, local)
476
+ except apimod.ErreurAPI as e:
477
+ ui.afficher_erreur(e)
478
+ continue
479
+ if not job:
480
+ continue
481
+ derniere_reponse = job.get("result") or ""
482
+ _afficher_job(job)
483
+ contexte.append(("user", ligne))
484
+ contexte.append(("nemesis", derniere_reponse))
485
+ contexte[:] = contexte[-CONTEXT_MAX * 2:]
486
+ if api:
487
+ ui.afficher_quota(api.quota())
488
+
489
+
490
+ # ─────────────────────────── point d'entrée ───────────────────────────
491
+
492
+ @click.command(context_settings={"ignore_unknown_options": True})
493
+ @click.argument("mots", nargs=-1, type=click.UNPROCESSED)
494
+ @click.option("-p", "--prompt", "prompt_txt", default=None,
495
+ help="Question unique, sortie puis fin.")
496
+ @click.option("--code", "demande_code", default=None,
497
+ help="Génère du code sans l'exécuter.")
498
+ @click.option("--local", "mode_local", is_flag=True,
499
+ help="Orchestrateur local (dev, hors quotas).")
500
+ @click.option("--timeout", type=int, default=600, show_default=True,
501
+ help="Délai max d'attente d'un job (s).")
502
+ @click.option("--version", "v", is_flag=True, help="Version du CLI.")
503
+ def main(mots, prompt_txt, demande_code, mode_local, timeout, v):
504
+ """NEMESIS — agents IA depuis le terminal."""
505
+ if v:
506
+ click.echo(f"nemesis {__version__}")
507
+ return
508
+
509
+ # sous-commandes directes
510
+ if mots and mots[0] in ("login", "logout", "whoami", "quota", "doc",
511
+ "chat"):
512
+ cfg = config.charger()
513
+ if mots[0] == "login":
514
+ if "--google" in mots:
515
+ _login_google()
516
+ elif "--email" in mots:
517
+ _login_email()
518
+ else:
519
+ _login()
520
+ elif mots[0] == "logout":
521
+ _logout()
522
+ elif mots[0] == "doc":
523
+ try:
524
+ _doc(_client(cfg), mots, timeout)
525
+ except apimod.ErreurAPI as e:
526
+ ui.afficher_erreur(e)
527
+ sys.exit(1)
528
+ elif mots[0] == "chat":
529
+ # Réponse directe via /v1/chat/completions — sans le
530
+ # pipeline job/polling de `nemesis "…"`.
531
+ question = " ".join(mots[1:]).strip()
532
+ if not question:
533
+ ui.avertir('Usage : nemesis chat "ta question"')
534
+ sys.exit(2)
535
+ try:
536
+ reponse = _client(cfg).completions(question)
537
+ except apimod.ErreurAPI as e:
538
+ ui.afficher_erreur(e)
539
+ sys.exit(1)
540
+ ui.afficher_reponse(reponse)
541
+ else:
542
+ try:
543
+ api = _client(cfg)
544
+ _whoami(api) if mots[0] == "whoami" else _afficher_quota_detail(api.quota())
545
+ except apimod.ErreurAPI as e:
546
+ ui.afficher_erreur(e)
547
+ sys.exit(1)
548
+ return
549
+
550
+ local = mode_local or os.getenv("NEMESIS_MODE") == "local"
551
+ cfg = config.charger()
552
+ api: apimod.API | None = None
553
+ email, plan = "", ""
554
+
555
+ if local:
556
+ ui.avertir("⚠ Mode local : quotas et plans non appliqués")
557
+ else:
558
+ try:
559
+ api = _client(cfg)
560
+ try:
561
+ st = api.statut()
562
+ email, plan = st.get("email", cfg.get("email", "")), st.get("plan", "")
563
+ except apimod.ErreurAPI:
564
+ email = cfg.get("email", "")
565
+ except apimod.ErreurAPI as e:
566
+ ui.afficher_erreur(e)
567
+ sys.exit(1)
568
+
569
+ question = prompt_txt or " ".join(mots).strip() or None
570
+
571
+ try:
572
+ if demande_code:
573
+ ui.entete(__version__, email, plan, "local" if local else "API")
574
+ _mode_code(api, demande_code, timeout, local)
575
+ elif question:
576
+ job = _envoyer(api, question, None, timeout, local)
577
+ _afficher_job(job)
578
+ if api and ui.est_interactif():
579
+ ui.afficher_quota(api.quota())
580
+ elif not ui.est_interactif() and not job:
581
+ sys.exit(1)
582
+ else:
583
+ ui.entete(__version__, email, plan, "local" if local else "API")
584
+ ui.console.print("[dim]/help pour les commandes · "
585
+ "Ctrl+D pour quitter[/dim]")
586
+ _boucle_chat(api, timeout, local)
587
+ finally:
588
+ if api:
589
+ api.close()
nemesis_cli/ui.py ADDED
@@ -0,0 +1,232 @@
1
+ """Rendu terminal : header, markdown, trace de l'équipe, quota, erreurs."""
2
+ from __future__ import annotations
3
+
4
+ import os
5
+ import sys
6
+ import time
7
+
8
+ from rich.console import Console
9
+ from rich.live import Live
10
+ from rich.markdown import Markdown
11
+ from rich.panel import Panel
12
+ from rich.table import Table
13
+ from rich.text import Text
14
+
15
+ from .api import ErreurAPI
16
+
17
+ NO_COLOR = os.getenv("NO_COLOR") is not None or os.getenv("TERM") == "dumb"
18
+ console = Console(no_color=NO_COLOR, highlight=False)
19
+
20
+
21
+ def est_interactif() -> bool:
22
+ return sys.stdout.isatty()
23
+
24
+
25
+ LOGO = r"""[cyan]
26
+ ███╗ ██╗███████╗███╗ ███╗███████╗███████╗██╗███████╗
27
+ ████╗ ██║██╔════╝████╗ ████║██╔════╝██╔════╝██║██╔════╝
28
+ ██╔██╗ ██║█████╗ ██╔████╔██║█████╗ ███████╗██║███████╗
29
+ ██║╚██╗██║██╔══╝ ██║╚██╔╝██║██╔══╝ ╚════██║██║╚════██║
30
+ ██║ ╚████║███████╗██║ ╚═╝ ██║███████║███████║██║███████║[/cyan]"""
31
+
32
+ # Trace de l'équipe : clé = sous-chaîne du champ job.current_agent de l'API.
33
+ ETAPES = [
34
+ ("aegon", "Aegon I découpe la demande"),
35
+ ("maekar", "Maekar I rassemble les sources"),
36
+ ("daemon", "Daemon rédige la réponse"),
37
+ ("daenerys", "Daenerys contrôle la qualité"),
38
+ ]
39
+
40
+
41
+ def _logo_pixel(largeur: int = 34):
42
+ """Logo officiel (le « N » bleu) rendu en demi-blocs Unicode
43
+ colorés (rich-pixels), ~`largeur` colonnes de large. Renvoie
44
+ None si rich-pixels/Pillow manque ou si l'asset est absent —
45
+ l'appelant retombe alors sur l'ASCII art."""
46
+ try:
47
+ from importlib import resources
48
+ from PIL import Image
49
+ from rich_pixels import Pixels
50
+ ref = resources.files("nemesis_cli").joinpath("assets/logo.png")
51
+ with resources.as_file(ref) as chemin:
52
+ img = Image.open(chemin)
53
+ img.load()
54
+ w, h = img.size
55
+ img = img.resize((largeur, max(1, round(h * largeur / w))))
56
+ return Pixels.from_image(img)
57
+ except Exception:
58
+ return None
59
+
60
+
61
+ def afficher_banniere(version: str) -> None:
62
+ """Logo NEMESIS + sous-titre — en-tête des écrans pleine page.
63
+ Vrai logo en pixel-art si possible, ASCII art en repli."""
64
+ if not est_interactif():
65
+ return
66
+ pixel = _logo_pixel()
67
+ if pixel is not None:
68
+ console.print(pixel)
69
+ else:
70
+ console.print(Text.from_markup(LOGO))
71
+ console.print(f" [dim]Agents IA depuis le terminal — "
72
+ f"v{version}[/dim]\n")
73
+
74
+
75
+ def afficher_succes(msg: str) -> None:
76
+ """Message de réussite bien visible (panneau vert)."""
77
+ if est_interactif():
78
+ console.print(Panel(f"[bold green]{msg}[/bold green]",
79
+ border_style="green", expand=False))
80
+ else:
81
+ print(msg)
82
+
83
+
84
+ def panneau(texte: str, titre: str = "", style: str = "cyan") -> None:
85
+ """Encadré d'information — repli en texte brut hors TTY."""
86
+ if est_interactif():
87
+ console.print(Panel(texte, title=titre or None,
88
+ border_style=style, expand=False))
89
+ else:
90
+ print(f"{titre} — {texte}" if titre else texte)
91
+
92
+
93
+ def entete(version: str, email: str = "", plan: str = "", mode: str = "API") -> None:
94
+ if not est_interactif():
95
+ return
96
+ afficher_banniere(version)
97
+ info = mode
98
+ if email:
99
+ info += f" · {email}"
100
+ if plan:
101
+ info += f" · plan {plan}"
102
+ console.print(f" [dim]{info}[/dim]\n")
103
+
104
+
105
+ def afficher_erreur(e: Exception) -> None:
106
+ msg = str(e) or e.__class__.__name__
107
+ if est_interactif():
108
+ console.print(Panel(msg, title="[red]Erreur[/red]",
109
+ border_style="red", expand=False))
110
+ else:
111
+ print(f"Erreur : {msg}", file=sys.stderr)
112
+
113
+
114
+ def afficher_reponse(texte: str, sources: list | None = None,
115
+ titre_job: str | None = None) -> None:
116
+ """Réponse markdown + sources numérotées [n] titre — domaine."""
117
+ if est_interactif():
118
+ if titre_job:
119
+ console.print(f"\n[cyan bold]NEMESIS[/cyan bold] — [dim]{titre_job}[/dim]")
120
+ else:
121
+ console.print("\n[cyan bold]NEMESIS[/cyan bold]")
122
+ console.print(Markdown(texte))
123
+ if sources:
124
+ console.print("\n[dim]Sources[/dim]")
125
+ for s in sources:
126
+ i, titre, url, domaine = (
127
+ s.get("id", "?"), s.get("title", "?"),
128
+ s.get("url", ""), s.get("domain", ""),
129
+ )
130
+ console.print(
131
+ f" [cyan][{i}][/cyan] {titre} — "
132
+ f"[dim]{domaine}[/dim] [blue underline]{url}[/blue underline]"
133
+ )
134
+ console.print()
135
+ else:
136
+ print(texte)
137
+ if sources:
138
+ print("\nSources :")
139
+ for s in sources:
140
+ print(f" [{s.get('id','?')}] {s.get('title','?')} — {s.get('url','')}")
141
+
142
+
143
+ def afficher_quota(quota: dict) -> None:
144
+ """Pied d'écran discret : tokens restants / limite."""
145
+ if not est_interactif() or not quota:
146
+ return
147
+ if quota.get("unlimited"):
148
+ console.print("[dim]tokens : illimités (admin)[/dim]")
149
+ return
150
+ restants, limite = quota.get("remaining"), quota.get("limit")
151
+ if restants is not None and limite:
152
+ console.print(
153
+ f"[dim]tokens : {restants:,} restants / {limite:,} "
154
+ f"· plan {quota.get('plan', '?')}[/dim]".replace(",", " "))
155
+
156
+
157
+ def _trace_table(idx_courant: int, debut: float) -> Table:
158
+ t = Table.grid(padding=(0, 1))
159
+ for i, (_, label) in enumerate(ETAPES):
160
+ if i < idx_courant:
161
+ t.add_row("[green]✓[/green]", f"[dim]{label}[/dim]")
162
+ elif i == idx_courant:
163
+ t.add_row("[cyan]⠋[/cyan]", label)
164
+ else:
165
+ t.add_row("[dim]·[/dim]", f"[dim]{label}[/dim]")
166
+ t.add_row("", f"[dim]{time.time() - debut:.0f} s[/dim]")
167
+ return t
168
+
169
+
170
+ def suivre_job(api, job_id: str, timeout: int = 600,
171
+ interactif: bool = True) -> dict:
172
+ """Poll GET /api/jobs/{id} : 1 s puis backoff jusqu'à 3 s.
173
+ Ctrl+C détache proprement (pas de route d'annulation côté serveur).
174
+ Renvoie le job terminé ; lève ErreurAPI sur échec/timeout."""
175
+ debut = time.time()
176
+ intervalle = 1.0
177
+
178
+ def poll() -> dict | None:
179
+ j = api.job(job_id)
180
+ if j.get("status") == "done":
181
+ return j
182
+ if j.get("status") == "failed":
183
+ raise ErreurAPI(j.get("error") or "Le job a échoué côté serveur.")
184
+ return None
185
+
186
+ if not interactif:
187
+ while time.time() - debut < timeout:
188
+ fini = poll()
189
+ if fini:
190
+ return fini
191
+ time.sleep(intervalle)
192
+ intervalle = min(intervalle * 1.4, 3.0)
193
+ raise ErreurAPI(f"Délai dépassé ({timeout} s) — le job continue "
194
+ "côté serveur, la réponse arrivera dans l'app.")
195
+
196
+ idx = 0
197
+ with Live(console=console, refresh_per_second=8, transient=True) as live:
198
+ while time.time() - debut < timeout:
199
+ j = api.job(job_id)
200
+ agent = (j.get("current_agent") or "").lower()
201
+ for i, (cle, _) in enumerate(ETAPES):
202
+ if cle in agent:
203
+ idx = max(idx, i)
204
+ if j.get("status") == "done":
205
+ live.update(_trace_table(len(ETAPES), debut))
206
+ return j
207
+ if j.get("status") == "failed":
208
+ raise ErreurAPI(j.get("error") or "Le job a échoué côté serveur.")
209
+ live.update(_trace_table(idx, debut))
210
+ time.sleep(intervalle)
211
+ intervalle = min(intervalle * 1.4, 3.0)
212
+ raise ErreurAPI(f"Délai dépassé ({timeout} s) — le job continue "
213
+ "côté serveur, la réponse arrivera dans l'app.")
214
+
215
+
216
+ def info(msg: str) -> None:
217
+ console.print(f"[green]{msg}[/green]")
218
+
219
+
220
+ def avertir(msg: str) -> None:
221
+ console.print(f"[yellow]{msg}[/yellow]")
222
+
223
+
224
+ def demander_confirm(question: str) -> bool:
225
+ """Oui/Non — non-interactif → refuse par prudence."""
226
+ if not est_interactif():
227
+ return False
228
+ try:
229
+ reponse = console.input(f"[yellow]{question} [o/N][/yellow] ")
230
+ except (EOFError, KeyboardInterrupt):
231
+ return False
232
+ return reponse.strip().lower() in ("o", "oui", "y", "yes")
@@ -0,0 +1,11 @@
1
+ Metadata-Version: 2.4
2
+ Name: nemesis-cli
3
+ Version: 1.0.2
4
+ Summary: Client terminal NEMESIS — agents IA depuis le terminal
5
+ Requires-Python: >=3.11
6
+ Requires-Dist: rich>=13.0
7
+ Requires-Dist: prompt_toolkit>=3.0
8
+ Requires-Dist: click>=8.0
9
+ Requires-Dist: httpx>=0.27
10
+ Requires-Dist: rich-pixels>=3.0
11
+ Requires-Dist: pillow>=10.0
@@ -0,0 +1,13 @@
1
+ nemesis_cli/__init__.py,sha256=zjcl-dQ5d-iSLrv7au-mA8ECAVRYTPvcPRKFvvFkK9s,80
2
+ nemesis_cli/__main__.py,sha256=W99dr-WmFlSlkMqU558RXfFjnZuj0BQY3THf_zCoc4M,89
3
+ nemesis_cli/api.py,sha256=CofVoP9IbiVYRPVbdvDywXHYGXypaBkPqCr2yMkdHW0,7997
4
+ nemesis_cli/commandes.py,sha256=pqd2v3sCOHfobor2vvPsLs6fc8Z6_-HoZluu-XI3T2k,8189
5
+ nemesis_cli/config.py,sha256=nyw8M0vsqg6hVAY3Xgb3ZEwCetVW2Ifb3YT4lZAgHrM,2232
6
+ nemesis_cli/main.py,sha256=3V6H2RoWnubKYabRg354nGF79ZefcTfZofCDn8Sv5Fk,22957
7
+ nemesis_cli/ui.py,sha256=535W9kVEsb3Le6aK4y1oatSSm58nSeL27CwsSpHt8EY,8945
8
+ nemesis_cli/assets/logo.png,sha256=uIrhykZn7zAx7kBuN62uaIP23kOgX8KjoMC_7_84nIs,25666
9
+ nemesis_cli-1.0.2.dist-info/METADATA,sha256=GCUNKmGu2I2RG4s2tPQv3WhIuE6WxP2rhBIG9sWQdJs,330
10
+ nemesis_cli-1.0.2.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
11
+ nemesis_cli-1.0.2.dist-info/entry_points.txt,sha256=_MI9LAq-qQpBWIJMGK6J_TD7_f_bqjAlBh1idJoOmw0,50
12
+ nemesis_cli-1.0.2.dist-info/top_level.txt,sha256=rWV7JLONtFjGZlMMu-nbn6liZ5aP42AMsVknEDESZug,12
13
+ nemesis_cli-1.0.2.dist-info/RECORD,,
@@ -0,0 +1,5 @@
1
+ Wheel-Version: 1.0
2
+ Generator: setuptools (84.2.1)
3
+ Root-Is-Purelib: true
4
+ Tag: py3-none-any
5
+
@@ -0,0 +1,2 @@
1
+ [console_scripts]
2
+ nemesis = nemesis_cli.main:main
@@ -0,0 +1 @@
1
+ nemesis_cli