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.
- nemesis_cli/__init__.py +3 -0
- nemesis_cli/__main__.py +4 -0
- nemesis_cli/api.py +209 -0
- nemesis_cli/assets/logo.png +0 -0
- nemesis_cli/commandes.py +210 -0
- nemesis_cli/config.py +61 -0
- nemesis_cli/main.py +589 -0
- nemesis_cli/ui.py +232 -0
- nemesis_cli-1.0.2.dist-info/METADATA +11 -0
- nemesis_cli-1.0.2.dist-info/RECORD +13 -0
- nemesis_cli-1.0.2.dist-info/WHEEL +5 -0
- nemesis_cli-1.0.2.dist-info/entry_points.txt +2 -0
- nemesis_cli-1.0.2.dist-info/top_level.txt +1 -0
nemesis_cli/__init__.py
ADDED
nemesis_cli/__main__.py
ADDED
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
|
nemesis_cli/commandes.py
ADDED
|
@@ -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 @@
|
|
|
1
|
+
nemesis_cli
|