nemesis-cli 1.0.2__tar.gz → 1.0.6__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.
Files changed (20) hide show
  1. {nemesis_cli-1.0.2 → nemesis_cli-1.0.6}/PKG-INFO +1 -3
  2. {nemesis_cli-1.0.2 → nemesis_cli-1.0.6}/backend/nemesis_cli/__init__.py +1 -1
  3. nemesis_cli-1.0.6/backend/nemesis_cli/agent.py +111 -0
  4. {nemesis_cli-1.0.2 → nemesis_cli-1.0.6}/backend/nemesis_cli/api.py +21 -4
  5. {nemesis_cli-1.0.2 → nemesis_cli-1.0.6}/backend/nemesis_cli/commandes.py +211 -210
  6. nemesis_cli-1.0.6/backend/nemesis_cli/main.py +1007 -0
  7. {nemesis_cli-1.0.2 → nemesis_cli-1.0.6}/backend/nemesis_cli/ui.py +9 -25
  8. {nemesis_cli-1.0.2 → nemesis_cli-1.0.6}/backend/nemesis_cli.egg-info/PKG-INFO +1 -3
  9. {nemesis_cli-1.0.2 → nemesis_cli-1.0.6}/backend/nemesis_cli.egg-info/SOURCES.txt +2 -2
  10. {nemesis_cli-1.0.2 → nemesis_cli-1.0.6}/backend/nemesis_cli.egg-info/requires.txt +0 -2
  11. {nemesis_cli-1.0.2 → nemesis_cli-1.0.6}/pyproject.toml +1 -6
  12. nemesis_cli-1.0.2/backend/nemesis_cli/assets/logo.png +0 -0
  13. nemesis_cli-1.0.2/backend/nemesis_cli/main.py +0 -589
  14. {nemesis_cli-1.0.2 → nemesis_cli-1.0.6}/README.md +0 -0
  15. {nemesis_cli-1.0.2 → nemesis_cli-1.0.6}/backend/nemesis_cli/__main__.py +0 -0
  16. {nemesis_cli-1.0.2 → nemesis_cli-1.0.6}/backend/nemesis_cli/config.py +0 -0
  17. {nemesis_cli-1.0.2 → nemesis_cli-1.0.6}/backend/nemesis_cli.egg-info/dependency_links.txt +0 -0
  18. {nemesis_cli-1.0.2 → nemesis_cli-1.0.6}/backend/nemesis_cli.egg-info/entry_points.txt +0 -0
  19. {nemesis_cli-1.0.2 → nemesis_cli-1.0.6}/backend/nemesis_cli.egg-info/top_level.txt +0 -0
  20. {nemesis_cli-1.0.2 → nemesis_cli-1.0.6}/setup.cfg +0 -0
@@ -1,11 +1,9 @@
1
1
  Metadata-Version: 2.4
2
2
  Name: nemesis-cli
3
- Version: 1.0.2
3
+ Version: 1.0.6
4
4
  Summary: Client terminal NEMESIS — agents IA depuis le terminal
5
5
  Requires-Python: >=3.11
6
6
  Requires-Dist: rich>=13.0
7
7
  Requires-Dist: prompt_toolkit>=3.0
8
8
  Requires-Dist: click>=8.0
9
9
  Requires-Dist: httpx>=0.27
10
- Requires-Dist: rich-pixels>=3.0
11
- Requires-Dist: pillow>=10.0
@@ -1,3 +1,3 @@
1
1
  """Client terminal NEMESIS — commande `nemesis`."""
2
2
 
3
- __version__ = "1.0.2"
3
+ __version__ = "1.0.6"
@@ -0,0 +1,111 @@
1
+ """Agent de code — actions fichiers du CLI NEMESIS.
2
+
3
+ L'IA annonce ses actions dans la réponse :
4
+
5
+ - un dossier à créer → ligne ``MKDIR:chemin/du/dossier``
6
+ - un fichier à écrire → bloc code annoté `` ```lang:chemin/fichier ``
7
+ - un fichier à relire → ligne ``READ:chemin/fichier``
8
+
9
+ En mode « manuel » chaque action attend une confirmation (o/n) ;
10
+ en « bypass » elles s'exécutent directement.
11
+ """
12
+ from __future__ import annotations
13
+
14
+ import re
15
+ from pathlib import Path
16
+
17
+ # Racine des écritures de l'agent : le dossier courant de l'utilisateur.
18
+ # Jamais de chemin absolu ni de « .. » — le sandbox est le cwd.
19
+ RACINE = Path.cwd()
20
+
21
+
22
+ def _chemin_sur(chemin: str) -> Path:
23
+ """Résout `chemin` sous le cwd — refuse absolu et « .. »."""
24
+ c = (chemin or "").strip()
25
+ if not c or ".." in c or ":" in c:
26
+ raise ValueError(f"chemin interdit : {chemin}")
27
+ c = c.lstrip("./\\")
28
+ if Path(c).is_absolute():
29
+ raise ValueError(f"chemin interdit : {chemin}")
30
+ p = (RACINE / c).resolve()
31
+ if not str(p).startswith(str(RACINE.resolve())):
32
+ raise ValueError(f"chemin hors du dossier courant : {chemin}")
33
+ return p
34
+
35
+
36
+ def creer_dossier(chemin: str) -> Path:
37
+ """Crée `chemin` (+ parents) sous le cwd. Renvoie le Path créé."""
38
+ p = _chemin_sur(chemin)
39
+ p.mkdir(parents=True, exist_ok=True)
40
+ return p
41
+
42
+
43
+ def creer_fichier(chemin: str, contenu: str) -> Path:
44
+ """Écrit `contenu` dans `chemin` (parents créés). Écrase si présent."""
45
+ p = _chemin_sur(chemin)
46
+ p.parent.mkdir(parents=True, exist_ok=True)
47
+ p.write_text(contenu, encoding="utf-8")
48
+ return p
49
+
50
+
51
+ def lire_fichier(chemin: str, max_chars: int = 20_000) -> str:
52
+ """Lit `chemin` sous le cwd — tronqué à max_chars caractères."""
53
+ p = _chemin_sur(chemin)
54
+ texte = p.read_text(encoding="utf-8", errors="replace")
55
+ return texte[:max_chars]
56
+
57
+
58
+ _RE_BLOC = re.compile(
59
+ r"```[\w.+#-]*\s*:\s*([^\n`]+?)\s*\n(.*?)```", re.DOTALL)
60
+ _RE_LIGNE = re.compile(r"^\s*(MKDIR|READ)\s*:\s*(.+?)\s*$",
61
+ re.MULTILINE | re.I)
62
+
63
+
64
+ def actions_dans_reponse(texte: str) -> list[dict]:
65
+ """Actions fichiers annoncées par l'IA, dans l'ordre du texte :
66
+ [{outil, chemin, contenu}] — outil ∈ creer_dossier/creer_fichier/
67
+ lire_fichier. Blocs code annotés `` ```lang:chemin `` → fichiers ;
68
+ lignes ``MKDIR:chemin`` / ``READ:chemin`` → dossier / lecture."""
69
+ if not texte:
70
+ return []
71
+ trouves = []
72
+ for m in _RE_BLOC.finditer(texte):
73
+ trouves.append((m.start(), {"outil": "creer_fichier",
74
+ "chemin": m.group(1).strip(),
75
+ "contenu": m.group(2)}))
76
+ for m in _RE_LIGNE.finditer(texte):
77
+ outil = ("creer_dossier" if m.group(1).upper() == "MKDIR"
78
+ else "lire_fichier")
79
+ trouves.append((m.start(), {"outil": outil,
80
+ "chemin": m.group(2)}))
81
+ return [a for _pos, a in sorted(trouves, key=lambda t: t[0])]
82
+
83
+
84
+ def executer(action: dict) -> str:
85
+ """Exécute une action détectée. Renvoie la ligne de flux à
86
+ afficher (« ✓ Fichier 'x' créé » / « x Erreur … »)."""
87
+ try:
88
+ if action["outil"] == "creer_dossier":
89
+ p = creer_dossier(action["chemin"])
90
+ return f"✓ Dossier « {action['chemin']} » créé ({p})"
91
+ if action["outil"] == "creer_fichier":
92
+ p = creer_fichier(action["chemin"],
93
+ action.get("contenu") or "")
94
+ return (f"✓ Fichier « {action['chemin']} » créé "
95
+ f"({p})")
96
+ if action["outil"] == "lire_fichier":
97
+ contenu = lire_fichier(action["chemin"])
98
+ return (f"✓ « {action['chemin']} » lu — "
99
+ f"{len(contenu)} caractères")
100
+ return f"x Outil inconnu : {action['outil']}"
101
+ except Exception as e:
102
+ return f"x {action['outil']} « {action['chemin']} » : {e}"
103
+
104
+
105
+ def libelle(action: dict) -> str:
106
+ """Phrase de confirmation mode manuel : « Créer le fichier "x" ?»"""
107
+ verbe = {"creer_dossier": "Créer le dossier",
108
+ "creer_fichier": "Créer le fichier",
109
+ "lire_fichier": "Lire le fichier"}.get(
110
+ action["outil"], action["outil"])
111
+ return f'{verbe} « {action["chemin"]} »'
@@ -165,12 +165,29 @@ class API:
165
165
  return self._req("POST", chemin, json=data).json()
166
166
 
167
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
- })
168
+ contexte: str | None = None, modele: str = "") -> str:
169
+ data = {"message": message, "template": template,
170
+ "context": contexte}
171
+ # Choix du menu : « reflexion »/« code_avance » sont les modes
172
+ # explicites du payload ; un slug devient modele_prefere ;
173
+ # « auto » (défaut) n'envoie rien — routage standard.
174
+ if modele == "reflexion":
175
+ data["reflexion"] = True
176
+ elif modele == "code_avance":
177
+ data["code_avance"] = True
178
+ elif modele and modele != "auto":
179
+ data["modele"] = modele
180
+ rep = self.post("/api/jobs", data)
172
181
  return rep["job_id"]
173
182
 
183
+ def modeles(self) -> list:
184
+ """GET /api/user/modeles — modèles sélectionnables du plan.
185
+ API ancienne ou erreur → [] (le CLI garde son comportement)."""
186
+ try:
187
+ return self.get("/api/user/modeles").get("modeles") or []
188
+ except Exception:
189
+ return []
190
+
174
191
  def completions(self, message: str,
175
192
  historique: list[dict] | None = None) -> str:
176
193
  """POST /v1/chat/completions (format OpenAI) — réponse directe,
@@ -1,210 +1,211 @@
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
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
+ "/model": "choisit le modèle IA (menu ↑/↓ + Entrée)",
26
+ }
27
+
28
+ TAILLE_MAX = 200 * 1024 # 200 Ko
29
+ LIGNES_APERTU = 400 # extrait si le fichier est énorme mais accepté
30
+
31
+ CHEMIN_SENSIBLE = re.compile(
32
+ r"(^|[/\\])\.env(\.|$)|\.pem$|id_rsa|\.key$|[/\\]\.ssh|[/\\]\.aws|"
33
+ r"[/\\]\.nemesis|\.pfx$|credentials\.json$", re.IGNORECASE)
34
+
35
+ SECRET_EVIDENT = re.compile(
36
+ r"sk-[A-Za-z0-9_\-]{10,}" # OpenAI/OpenRouter
37
+ r"|sk-ant-[A-Za-z0-9_\-]{10,}" # Anthropic
38
+ r"|xox[baprs]-[A-Za-z0-9\-]{10,}" # Slack
39
+ r"|AKIA[0-9A-Z]{16}" # AWS access key
40
+ r"|gh[pousr]_[A-Za-z0-9]{20,}" # GitHub
41
+ r"|-----BEGIN [A-Z ]*PRIVATE KEY-----"
42
+ r"|service_role['\"\s:=]+[A-Za-z0-9_\-\.]{20,}"
43
+ r"|eyJ[A-Za-z0-9_\-]{10,}\.eyJ[A-Za-z0-9_\-]{10,}") # JWT
44
+
45
+
46
+ def parser_commande(ligne: str) -> tuple[str, list[str]] | None:
47
+ """'/pdf rapport marché' → ('/pdf', ['rapport', 'marché']). None sinon."""
48
+ ligne = ligne.strip()
49
+ if not ligne.startswith("/"):
50
+ return None
51
+ try:
52
+ mots = shlex.split(ligne)
53
+ except ValueError:
54
+ mots = ligne.split()
55
+ if not mots:
56
+ return None
57
+ return mots[0].lower(), mots[1:]
58
+
59
+
60
+ def aide() -> str:
61
+ lignes = ["Commandes :"]
62
+ for cmd, desc in COMMANDES.items():
63
+ lignes.append(f" {cmd:34s} {desc}")
64
+ lignes.append(" Entrée=envoyer · Alt+Maj+Entrée=nouvelle ligne · "
65
+ "Ctrl+C=annule · Ctrl+D=quitte")
66
+ return "\n".join(lignes)
67
+
68
+
69
+ # ───────────────────────────── /file ─────────────────────────────
70
+
71
+ def lire_fichier(chemin: str, confirmer=ui.demander_confirm) -> str | None:
72
+ """Lit un fichier avec garde-fous. Renvoie le bloc de contexte markdown
73
+ ou None si refusé. Lève ValueError avec message français."""
74
+ p = Path(chemin).expanduser()
75
+ if not p.exists():
76
+ raise ValueError(f"Fichier introuvable : {chemin}")
77
+ if not p.is_file():
78
+ raise ValueError(f"Pas un fichier : {chemin}")
79
+
80
+ rel = str(p)
81
+ if CHEMIN_SENSIBLE.search(rel) or CHEMIN_SENSIBLE.search(p.name):
82
+ if not confirmer(f"⚠ {p.name} est un chemin sensible "
83
+ f"(clés/env). L'envoyer quand même ?"):
84
+ raise ValueError(f"{p.name} : envoi refusé (chemin sensible).")
85
+
86
+ taille = p.stat().st_size
87
+ if taille > TAILLE_MAX:
88
+ raise ValueError(
89
+ f"{p.name} fait {taille // 1024} Ko (max 200 Ko). "
90
+ "Coupe-le ou résume-le d'abord.")
91
+ try:
92
+ texte = p.read_text(encoding="utf-8")
93
+ except UnicodeDecodeError:
94
+ raise ValueError(f"{p.name} n'est pas du texte lisible "
95
+ "(binaire ?).")
96
+
97
+ if SECRET_EVIDENT.search(texte):
98
+ if not confirmer(f"⚠ {p.name} semble contenir des secrets "
99
+ f"(clés API, tokens…). Envoyer quand même ?"):
100
+ raise ValueError(f"{p.name} : envoi refusé (secret détecté).")
101
+
102
+ lignes = texte.splitlines()
103
+ extrait = texte
104
+ if len(lignes) > LIGNES_APERTU:
105
+ extrait = "\n".join(lignes[:LIGNES_APERTU])
106
+ extrait += f"\n… ({len(lignes) - LIGNES_APERTU} lignes restantes)"
107
+ ui.info(f"📎 {p.name} ({len(lignes)} lignes) joint")
108
+ return f"### Fichier `{p.name}`\n```\n{extrait}\n```"
109
+
110
+
111
+ def jointures(chemins: list[str], confirmer=ui.demander_confirm) -> str:
112
+ """/file a b c → un bloc de contexte markdown. Erreurs collectées."""
113
+ blocs, erreurs = [], []
114
+ for c in chemins:
115
+ try:
116
+ blocs.append(lire_fichier(c, confirmer))
117
+ except ValueError as e:
118
+ erreurs.append(str(e))
119
+ for e in erreurs:
120
+ ui.afficher_erreur(ValueError(e))
121
+ return "\n\n".join(b for b in blocs if b)
122
+
123
+
124
+ # ───────────────────────────── /save & /copy ─────────────────────────────
125
+
126
+ EXTS = {"python": ".py", "py": ".py", "javascript": ".js", "js": ".js",
127
+ "typescript": ".ts", "ts": ".ts", "html": ".html", "css": ".css",
128
+ "bash": ".sh", "sh": ".sh", "json": ".json", "sql": ".sql",
129
+ "yaml": ".yaml", "yml": ".yml", "go": ".go", "rust": ".rs",
130
+ "java": ".java", "c": ".c", "cpp": ".cpp"}
131
+
132
+
133
+ def dernier_bloc_code(texte: str) -> tuple[str, str] | None:
134
+ """Extrait le dernier ```lang … ``` → (lang, code)."""
135
+ blocs = re.findall(r"```(\w*)\n(.*?)```", texte, re.DOTALL)
136
+ if not blocs:
137
+ return None
138
+ return blocs[-1]
139
+
140
+
141
+ def nom_defaut(texte: str, base: str = "nemesis") -> str:
142
+ bloc = dernier_bloc_code(texte)
143
+ if bloc:
144
+ return base + EXTS.get(bloc[0].lower(), ".txt")
145
+ return base + ".md"
146
+
147
+
148
+ def sauvegarder(contenu: str, nom: str,
149
+ confirmer=ui.demander_confirm) -> Path | None:
150
+ """Écrit `contenu` dans `nom` — jamais hors du dossier courant ni
151
+ écrasement sans confirmation. Renvoie le chemin absolu."""
152
+ dest = Path(nom).expanduser()
153
+ if not dest.is_absolute():
154
+ dest = (Path.cwd() / dest).resolve()
155
+ else:
156
+ dest = dest.resolve()
157
+
158
+ if Path.cwd() not in dest.parents and dest != Path.cwd():
159
+ if not confirmer(f"⚠ {dest} est hors du dossier courant "
160
+ f"({Path.cwd()}). Écrire quand même ?"):
161
+ ui.avertir("Enregistrement annulé (hors dossier courant).")
162
+ return None
163
+ if dest.exists():
164
+ if not confirmer(f"⚠ {dest.name} existe déjà. Écraser ?"):
165
+ ui.avertir("Enregistrement annulé.")
166
+ return None
167
+ dest.parent.mkdir(parents=True, exist_ok=True)
168
+ dest.write_text(contenu, encoding="utf-8")
169
+ ui.info(f"✓ Enregistré : {dest}")
170
+ return dest
171
+
172
+
173
+ def sauvegarder_bytes(data: bytes, nom: str,
174
+ confirmer=ui.demander_confirm) -> Path | None:
175
+ """Idem sauvegarder() mais pour du binaire (PDF téléchargé)."""
176
+ dest = Path(nom)
177
+ if not dest.is_absolute():
178
+ dest = (Path.cwd() / dest).resolve()
179
+ if Path.cwd() not in dest.parents and dest != Path.cwd():
180
+ if not confirmer(f"⚠ {dest} est hors du dossier courant. "
181
+ "Écrire quand même ?"):
182
+ ui.avertir("Enregistrement annulé.")
183
+ return None
184
+ if dest.exists() and not confirmer(f"⚠ {dest.name} existe. Écraser ?"):
185
+ ui.avertir("Enregistrement annulé.")
186
+ return None
187
+ dest.parent.mkdir(parents=True, exist_ok=True)
188
+ dest.write_bytes(data)
189
+ ui.info(f"✓ Enregistré : {dest}")
190
+ return dest
191
+
192
+
193
+ def copier(texte: str) -> bool:
194
+ """Copie dans le presse-papiers (clip.exe / pbcopy / xclip / wl-copy)."""
195
+ essais = []
196
+ if sys.platform.startswith("win"):
197
+ essais = [["clip"]]
198
+ elif sys.platform == "darwin":
199
+ essais = [["pbcopy"]]
200
+ else:
201
+ essais = [["wl-copy"], ["xclip", "-selection", "clipboard"],
202
+ ["xsel", "-b"]]
203
+ for cmd in essais:
204
+ try:
205
+ subprocess.run(cmd, input=texte.encode("utf-8"),
206
+ check=True, capture_output=True, timeout=5)
207
+ return True
208
+ except (FileNotFoundError, subprocess.CalledProcessError,
209
+ subprocess.TimeoutExpired):
210
+ continue
211
+ return False