nemesis-cli 1.0.2__tar.gz
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-1.0.2/PKG-INFO +11 -0
- nemesis_cli-1.0.2/README.md +82 -0
- nemesis_cli-1.0.2/backend/nemesis_cli/__init__.py +3 -0
- nemesis_cli-1.0.2/backend/nemesis_cli/__main__.py +4 -0
- nemesis_cli-1.0.2/backend/nemesis_cli/api.py +209 -0
- nemesis_cli-1.0.2/backend/nemesis_cli/assets/logo.png +0 -0
- nemesis_cli-1.0.2/backend/nemesis_cli/commandes.py +210 -0
- nemesis_cli-1.0.2/backend/nemesis_cli/config.py +61 -0
- nemesis_cli-1.0.2/backend/nemesis_cli/main.py +589 -0
- nemesis_cli-1.0.2/backend/nemesis_cli/ui.py +232 -0
- nemesis_cli-1.0.2/backend/nemesis_cli.egg-info/PKG-INFO +11 -0
- nemesis_cli-1.0.2/backend/nemesis_cli.egg-info/SOURCES.txt +16 -0
- nemesis_cli-1.0.2/backend/nemesis_cli.egg-info/dependency_links.txt +1 -0
- nemesis_cli-1.0.2/backend/nemesis_cli.egg-info/entry_points.txt +2 -0
- nemesis_cli-1.0.2/backend/nemesis_cli.egg-info/requires.txt +6 -0
- nemesis_cli-1.0.2/backend/nemesis_cli.egg-info/top_level.txt +1 -0
- nemesis_cli-1.0.2/pyproject.toml +35 -0
- nemesis_cli-1.0.2/setup.cfg +4 -0
|
@@ -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,82 @@
|
|
|
1
|
+
# NEMESIS
|
|
2
|
+
|
|
3
|
+
Plateforme d'orchestration d'agents IA autonomes.
|
|
4
|
+
|
|
5
|
+
## Structure
|
|
6
|
+
|
|
7
|
+
- `backend/` — Cœur du système (Python, CrewAI)
|
|
8
|
+
- `frontend/` — Interface et landing (React, Vite)
|
|
9
|
+
- `docs/` — Documentation
|
|
10
|
+
|
|
11
|
+
## Stack
|
|
12
|
+
|
|
13
|
+
Backend : Python 3.12, CrewAI, FastAPI, LiteLLM
|
|
14
|
+
Frontend : React 19, Vite 8, Tailwind CSS 4
|
|
15
|
+
LLM : OpenRouter (principal), Groq, Cerebras (fallbacks)
|
|
16
|
+
Pilotage : Web, Telegram, CLI
|
|
17
|
+
|
|
18
|
+
## Lancer en local
|
|
19
|
+
|
|
20
|
+
### 1. Backend (`backend/.env`)
|
|
21
|
+
|
|
22
|
+
Copier `backend/.env.example` → `backend/.env` et renseigner les
|
|
23
|
+
variables (le `.env` est lu quel que soit le dossier de lancement) :
|
|
24
|
+
|
|
25
|
+
- LLM : `OPENROUTER_API_KEY`, `GROQ_API_KEY`, `CEREBRAS_API_KEY`
|
|
26
|
+
- Recherche : `SERPER_API_KEY`
|
|
27
|
+
- Supabase : `SUPABASE_URL`, `SUPABASE_SERVICE_ROLE_KEY`, `SUPABASE_JWT_SECRET`
|
|
28
|
+
- CORS local (obligatoire : aucune origine locale n'est acceptée par défaut) :
|
|
29
|
+
`CORS_ORIGINS=http://localhost:5173,http://127.0.0.1:5173`
|
|
30
|
+
|
|
31
|
+
```bash
|
|
32
|
+
cd backend
|
|
33
|
+
venv\Scripts\activate # Windows (ou source venv/bin/activate)
|
|
34
|
+
pip install -r requirements.txt
|
|
35
|
+
uvicorn api.main:app --host 127.0.0.1 --port 8000 --reload
|
|
36
|
+
```
|
|
37
|
+
|
|
38
|
+
### 2. Frontend (`frontend/.env.local`)
|
|
39
|
+
|
|
40
|
+
Copier `frontend/.env.example` → `frontend/.env.local` :
|
|
41
|
+
|
|
42
|
+
```
|
|
43
|
+
VITE_API_URL=http://127.0.0.1:8000
|
|
44
|
+
VITE_SUPABASE_URL=…
|
|
45
|
+
VITE_SUPABASE_ANON_KEY=…
|
|
46
|
+
```
|
|
47
|
+
|
|
48
|
+
⚠️ Utiliser `127.0.0.1` si uvicorn écoute sur `127.0.0.1` : sous Windows,
|
|
49
|
+
`localhost` peut résoudre en `::1` (IPv6) alors que le serveur n'écoute
|
|
50
|
+
qu'en IPv4 → « Failed to fetch » dans le navigateur.
|
|
51
|
+
|
|
52
|
+
```bash
|
|
53
|
+
cd frontend
|
|
54
|
+
npm install
|
|
55
|
+
npm run dev # http://localhost:5173
|
|
56
|
+
```
|
|
57
|
+
|
|
58
|
+
### 3. Supabase Dashboard (auth en local)
|
|
59
|
+
|
|
60
|
+
Dans **Authentication → URL Configuration** :
|
|
61
|
+
|
|
62
|
+
- **Site URL** : `http://localhost:5173`
|
|
63
|
+
- **Redirect URLs** : ajouter `http://localhost:5173/auth/callback`
|
|
64
|
+
(et `http://127.0.0.1:5173/auth/callback` si vous ouvrez le front en IP)
|
|
65
|
+
|
|
66
|
+
Sans ces URLs, le login Google retombe sur l'URL de production.
|
|
67
|
+
|
|
68
|
+
### Sécurité
|
|
69
|
+
|
|
70
|
+
Les fichiers `.env`, `.env.local` et `*.local` sont ignorés par git —
|
|
71
|
+
ne jamais les committer. Les `.env.example` ne contiennent que des noms.
|
|
72
|
+
|
|
73
|
+
## Auteur
|
|
74
|
+
|
|
75
|
+
Yrigalé Saint Michel
|
|
76
|
+
- GitHub : https://github.com/BigsaintMichel
|
|
77
|
+
- LinkedIn : https://www.linkedin.com/in/saint-michel-yirigale-945570328
|
|
78
|
+
- Email : saintmichelyirigale@gmail.com
|
|
79
|
+
|
|
80
|
+
## Licence
|
|
81
|
+
|
|
82
|
+
Projet privé — Tous droits réservés.
|
|
@@ -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
|
|
@@ -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)
|