@nosserb/prmt 0.0.0-stage → 2.0.0

package/tui/promethee/app/validation.py

@@ -0,0 +1,210 @@
+"""Validation par l'utilisateur et exécution des commandes."""
+from __future__ import annotations
+
+import os
+import subprocess
+import tempfile
+import threading
+import time
+from pathlib import Path
+
+from rich.text import Text
+from textual.containers import Vertical
+
+from ..config import CMD_TIMEOUT, CREATE_NO_WINDOW
+from ..consignes import WRITE_TOOL
+from ..fichiers import render_diff
+from ..securite import can_auto_allow, is_dangerous, session_scope
+from ..shell import CWD_MARK, build_script, decode_output, refreshed_env, tidy_output
+from ..theme import DIM, RED
+from ..widgets import ChoicePrompt, PermissionPrompt
+
+
+class Validation:
+    """Partie de PrometheeApp : validation par l'utilisateur et exécution des commandes."""
+
+    # ------------------------------------------------------------------ validation des commandes et fichiers
+    def _ask_permission(self, command: str, explanation: str, verdict=None) -> str:
+        """Affiche la demande de validation et attend la réponse (appelé depuis le thread de l'agent)."""
+        return self._wait_choice(lambda done: self.show_permission(command, explanation, done, verdict))
+
+    def _wait_choice(self, show) -> str:
+        answered = threading.Event()
+        box: dict[str, str] = {}
+
+        def done(decision: str) -> None:
+            box["decision"] = decision
+            answered.set()
+
+        self.call_from_thread(show, done)
+        while not answered.wait(0.1):
+            if self.cancel_event.is_set():
+                return "no"
+        self.call_from_thread(self.hide_permission)
+        return box.get("decision", "no")
+
+    def show_permission(self, command: str, explanation: str, callback, verdict=None, direct: bool = False) -> None:
+        """verdict : celui de la politique (None : validation manuelle). direct : commande « ! » tapée par toi."""
+        # Une commande destructrice que tu as débloquée reste signalée en rouge
+        dangerous = is_dangerous(command) or (verdict is not None and any(r.code == "unlocked" for r in verdict.raisons))
+        # Option « ne plus demander » seulement pour les commandes simples, non risquées et, si la politique répond,
+        # classées en lecture. Elle vaut pour le nom d'une lecture reconnue, sinon pour la ligne exacte.
+        scope, items = session_scope(command) if can_auto_allow(command) and not direct else ("noms", [])
+        if direct:
+            prompt = PermissionPrompt(command, explanation, dangerous, [], callback, verdict=verdict,
+                                      title="Exécuter ta commande", question="Tu l'as tapée toi-même : l'exécuter ?",
+                                      refusal="Non (Esc)")
+        else:
+            prompt = PermissionPrompt(command, explanation, dangerous, items, callback, verdict=verdict, scope=scope)
+        if self._agent_name:
+            prompt.title += f"  ·  demandé par l'agent {self._agent_name}"
+        self.show_prompt(prompt)
+
+    def show_edit_permission(self, tool: str, path: Path, old: str | None, new: str, explanation: str,
+                             outside: bool, callback, sensitive: str = "") -> None:
+        diff, _, _ = render_diff(old, new, max_lines=max(8, self.size.height - 20))
+        body = Text()
+        body.append(f"  {path}\n", style="bold")
+        if explanation:
+            body.append(f"  {explanation}\n", style=DIM)
+        body.append("\n")
+        body.append_text(diff)
+        if outside:
+            body.append("\n\n  ⚠ Ce fichier est en dehors de ton dossier utilisateur : vérifie bien le chemin.",
+                        style=f"bold {RED}")
+        elif sensitive:
+            body.append(f"\n\n  ⚠ Fichier sensible ({sensitive}) : il te sera toujours montré avant d'être écrit.",
+                        style=f"bold {RED}")
+        if old is None:
+            title, question = "Créer un fichier", "Créer ce fichier ?"
+        elif tool == WRITE_TOOL:
+            title, question = "Remplacer le contenu d'un fichier", "Remplacer tout le contenu de ce fichier ?"
+        else:
+            title, question = "Modifier un fichier", "Appliquer ces modifications ?"
+        options = [("yes", "Oui")]
+        if not outside and not sensitive:
+            options.append(("always", "Oui, et autoriser toutes les modifications de fichiers pendant cette session"))
+        options.append(("no", "Non, et dire à Prométhée quoi faire autrement (Esc)"))
+        if self._agent_name:
+            title += f"  ·  demandé par l'agent {self._agent_name}"
+        self.show_prompt(ChoicePrompt(title, body, question, options, callback, danger=outside or bool(sensitive),
+                                      command=str(path)))
+
+    def ask(self, title: str, body: Text | None, question: str, options: list[tuple[str, str]], on_choice,
+            esc: str = "annuler", enter: str = "valider", danger: bool = False) -> ChoicePrompt:
+        """Pose une question à choix sous la conversation. L'invite se referme, puis on_choice reçoit la réponse
+        (« no » si tu fais Esc). esc et enter disent, dans l'aide du bas, ce que font ces deux touches."""
+        def chosen(decision: str) -> None:
+            if self._perm is prompt:
+                self.hide_permission()
+            on_choice(decision)
+
+        prompt = ChoicePrompt(title, body, question, options, chosen, danger=danger)
+        prompt.hint = f"↑↓ choisir · Entrée {enter} (ou tape le numéro) · Esc {esc}"
+        self.show_prompt(prompt)
+        return prompt
+
+    def show_prompt(self, prompt: ChoicePrompt) -> None:
+        self._perm = prompt
+        self._comp_items = []
+        self.render_completions()
+        self._spinner(False)
+        self.query_one("#input-box").display = False
+        self.query_one("#bottom", Vertical).mount(prompt, before="#status-line")
+        self.call_after_refresh(prompt.focus)
+        self.set_hints()
+
+    def hide_permission(self) -> None:
+        prompt, self._perm = self._perm, None
+        if prompt is not None:
+            prompt.remove()
+        self.query_one("#input-box").display = True
+        self.input.focus()
+        self.set_hints()
+
+    def is_allowed(self, command: str, verdict=None) -> bool:
+        """La commande peut-elle partir sans te la redemander ? Jamais si la politique ne la classe pas en lecture."""
+        if not can_auto_allow(command) or (verdict is not None and not verdict.lecture):
+            return False
+        scope, items = session_scope(command)
+        return all(w in self.allowed for w in items) if scope == "noms" else items[0] in self.allowed_lines
+
+    def allow(self, command: str) -> None:
+        if can_auto_allow(command):
+            scope, items = session_scope(command)
+            (self.allowed if scope == "noms" else self.allowed_lines).update(items)
+
+    # ------------------------------------------------------------------ exécution (thread)
+    def _execute(self, command: str, verdict=None) -> tuple[int | None, str, str]:
+        # Script dans un .ps1 temporaire (UTF-8 avec BOM pour PowerShell 5.1) lancé avec -File :
+        # avec -EncodedCommand, PowerShell renvoie les erreurs et Write-Host en XML (CLIXML).
+        # verdict : une commande autorisée par la liste blanche s'exécute en mode de langage contraint.
+        constrained = verdict is not None and verdict.mode_contraint
+        script_path = ""
+        try:
+            fd, script_path = tempfile.mkstemp(prefix="prmt_", suffix=".ps1")
+            with os.fdopen(fd, "w", encoding="utf-8-sig", newline="\r\n") as f:
+                f.write(build_script(command, verdict.modules if constrained else (), constrained))
+            proc = subprocess.Popen(
+                ["powershell.exe", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-File", script_path],
+                cwd=str(self.cwd),
+                env=refreshed_env(),
+                stdin=subprocess.DEVNULL,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                creationflags=CREATE_NO_WINDOW,
+            )
+            return self._wait(proc)
+        except OSError as err:
+            return None, f"Impossible de lancer PowerShell : {err}", ""
+        finally:
+            if script_path:
+                try:
+                    os.remove(script_path)
+                except OSError:
+                    pass
+
+    def _wait(self, proc: subprocess.Popen) -> tuple[int | None, str, str]:
+        self._proc = proc
+        start = time.monotonic()
+        chunks: list[bytes] = []
+        note = ""
+        try:
+            while True:
+                try:
+                    out, _ = proc.communicate(timeout=0.25)
+                    chunks.append(out or b"")
+                    break
+                except subprocess.TimeoutExpired:
+                    if self.cancel_event.is_set():
+                        note = "arrêtée par toi"
+                    elif time.monotonic() - start > CMD_TIMEOUT:
+                        note = f"arrêtée après {CMD_TIMEOUT // 60} min (délai dépassé)"
+                    else:
+                        continue
+                    self._kill_proc()
+                    try:
+                        out, _ = proc.communicate(timeout=5)
+                    except subprocess.TimeoutExpired:
+                        out = b""   # un processus enfant garde la sortie ouverte : on n'attend pas davantage
+                    chunks.append(out or b"")
+                    break
+        finally:
+            self._proc = None
+        output = decode_output(b"".join(chunks))
+        # Suivi du dossier courant (cd / Set-Location) : on retire le marqueur où qu'il soit
+        idx = output.rfind(CWD_MARK)
+        if idx != -1:
+            end = output.find("\n", idx)
+            new_cwd = Path(output[idx + len(CWD_MARK): end if end != -1 else len(output)].strip())
+            if new_cwd.is_dir():
+                self.cwd = new_cwd
+            output = output[:idx] + (output[end + 1:] if end != -1 else "")
+        output = tidy_output(output)
+        code = None if note else proc.returncode
+        return code, output, note
+
+    def _kill_proc(self) -> None:
+        proc = self._proc
+        if proc is not None and proc.poll() is None:
+            subprocess.run(["taskkill", "/T", "/F", "/PID", str(proc.pid)], capture_output=True, creationflags=CREATE_NO_WINDOW)

package/tui/promethee/appels.py

@@ -0,0 +1,35 @@
+"""Appels d'outils du modèle : lecture des arguments, tri des appels lancés à l'aveugle."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from .agents import AGENT_TOOL
+from .consignes import READ_TOOL, SEARCH_TOOL_NAMES
+from .fichiers import resolve_path
+
+
+def call_args(call: dict) -> dict:
+    args = (call.get("function") or {}).get("arguments") or {}
+    if isinstance(args, str):
+        try:
+            args = json.loads(args)
+        except json.JSONDecodeError:
+            return {}
+    return args if isinstance(args, dict) else {}
+
+
+def prune_calls(calls: list[dict], cwd: Path) -> list[dict]:
+    """Appels lancés « à l'aveugle » dans un même tour, que le modèle 8B fait souvent :
+    - lancer_agent en plus de ses propres outils : il confie alors à l'agent une tâche hors sujet, puis croit son
+      rapport plutôt que la vraie sortie → on garde seulement ses propres outils ;
+    - chercher_fichiers ET lire_fichier de fichiers inventés (« fichier1.txt ») avant d'avoir vu le résultat
+      → on garde la recherche et les lectures de fichiers qui existent : il lira les vrais au tour suivant."""
+    names = [(c.get("function") or {}).get("name") for c in calls]
+    if AGENT_TOOL in names and any(n != AGENT_TOOL for n in names):
+        calls = [c for c, n in zip(calls, names) if n != AGENT_TOOL]
+        names = [n for n in names if n != AGENT_TOOL]
+    if any(n in SEARCH_TOOL_NAMES for n in names) and READ_TOOL in names:
+        calls = [c for c, n in zip(calls, names) if n != READ_TOOL
+                 or resolve_path(str(call_args(c).get("chemin") or "?"), cwd).is_file()]
+    return calls

package/tui/promethee/commandes.py

@@ -0,0 +1,154 @@
+"""Commandes « / » : la liste intégrée, les commandes personnalisées et /init."""
+from __future__ import annotations
+
+import os
+import re
+from pathlib import Path
+from typing import NamedTuple
+
+from .agents import agent_slug
+from .config import SAVE_DIR
+from .fichiers import read_text_file
+
+# --------------------------------------------------------------------------- Commandes personnalisées (comme .claude/commands)
+# Un fichier nom.md = une commande /nom : son texte est envoyé à Prométhée, $ARGUMENTS remplacé par ce qui suit /nom.
+COMMANDS_DIR = SAVE_DIR / "commandes"               # commandes globales
+LOCAL_COMMANDS = Path(".promethee") / "commandes"   # commandes d'un dossier
+COMMAND_SCHEMA = {"type": "object", "properties": {
+    "nom": {"type": "string"},
+    "description": {"type": "string"},
+    "argument": {"type": "string"},
+    "consignes": {"type": "string"},
+}, "required": ["nom", "description", "argument", "consignes"]}
+COMMAND_GEN_SYSTEM = """Tu écris des commandes personnalisées pour Prométhée, un assistant de cybersécurité local sous Windows 11 (PowerShell 5.1). Une commande est un message type que l'utilisateur lance en tapant /nom suivi d'un argument. À partir de sa description, écris :
+- nom : court, en minuscules, mots séparés par des tirets (par exemple « scan-reseau », « revue-script »).
+- description : une phrase : ce que fait la commande.
+- argument : ce que l'utilisateur tape après /nom (par exemple « <adresse ou plage IP> », « <fichier> »), ou "" s'il n'y en a pas.
+- consignes : le message envoyé à Prométhée, à l'impératif, en le tutoyant, en 3 à 10 lignes : ce qu'il doit faire étape par étape et ce que doit contenir sa réponse. C'est Prométhée qui agit lui-même avec ses outils (executer_commande pour les commandes, lire_fichier, chercher_fichiers, chercher_texte) : écris « Lance … avec executer_commande », jamais des consignes pour un humain (« Exécutez … »). Écris $ARGUMENTS à l'endroit où va l'argument de l'utilisateur.
+Cite seulement des commandes PowerShell qui existent vraiment, avec leurs vrais paramètres, entre backticks.
+Réponds uniquement en JSON."""
+COMMAND_TEMPLATE = {"name": "ma-commande", "description": "Ce que fait cette commande.", "argument": "<cible>",
+                    "prompt": "Fais … sur $ARGUMENTS.\n\n1. …\n2. …\n\nTermine par un résumé : …"}
+
+
+class Commande(NamedTuple):
+    """Une commande « / » intégrée. action : la méthode de PrometheeApp qui la traite (elle reçoit ce qui suit le nom)."""
+    nom: str
+    alias: tuple[str, ...]
+    description: str
+    action: str
+
+
+# Le seul endroit où une commande intégrée est déclarée : le menu « / », l'aiguillage (app/commandes_slash.py) et les
+# noms réservés (une commande personnalisée ne peut pas les prendre) partent tous de cette liste.
+COMMANDS = [
+    Commande("/aide", ("help", "?", "h"), "afficher l'aide", "cmd_aide"),
+    Commande("/etat", ("état", "status", "statut"), "état de la plateforme : IA, moteur, périmètre, activité", "cmd_etat"),
+    Commande("/clear", ("nouveau", "reset", "new"), "nouvelle conversation", "clear_conversation"),
+    Commande("/compact", ("compacter", "resumer", "résumer"), "résumer la conversation pour libérer le contexte", "cmd_compact"),
+    Commande("/reprendre", ("resume", "continuer", "sessions", "historique"), "reprendre une conversation précédente", "cmd_resume"),
+    Commande("/memoire", ("memory", "mémoire"), "voir la mémoire PROMETHEE.md (/memoire ouvrir : la modifier)", "cmd_memoire"),
+    Commande("/plan", (), "activer ou couper le mode plan (aussi Shift+Tab)", "cmd_plan"),
+    Commande("/agents", ("agent",), "créer, voir et gérer les agents (sous-agents)", "cmd_agents"),
+    Commande("/code", (), "IA de code : bascule automatique (on / off) et modèle utilisé", "cmd_code"),
+    Commande("/commandes", ("commands",), "créer, voir et gérer tes commandes personnalisées", "cmd_commands"),
+    Commande("/init", (), "écrire la mémoire PROMETHEE.md de ce dossier (Prométhée l'explore)", "cmd_init"),
+    Commande("/contexte", ("context",), "ce qui remplit le contexte du modèle", "cmd_context"),
+    Commande("/modele", ("model", "modèle", "models", "modeles", "modèles"), "lister les modèles ou en changer", "cmd_modele"),
+    Commande("/copier", ("copy", "cp"), "copier la dernière réponse (/copier code : les blocs de code)", "cmd_copy"),
+    Commande("/sortie", ("output",), "sortie complète de la dernière commande", "cmd_sortie"),
+    Commande("/politique", ("policy",), "politique d'exécution : stricte ou souple, liste blanche", "cmd_politique"),
+    Commande("/permissions", ("perms", "autorisations"), "autorisations de la session, débloquer ou ajouter une commande", "cmd_permissions"),
+    Commande("/perimetre", ("périmètre", "scope", "cibles"), "cibles réseau que tu as le droit de tester", "cmd_perimetre"),
+    Commande("/journal", ("log", "logs"), "dernières actions : commandes exécutées, refusées, fichiers écrits", "cmd_journal"),
+    Commande("/recherche", ("web", "internet", "searxng"), "recherche web par SearXNG : état, on, off", "cmd_recherche"),
+    Commande("/theme", ("thème", "fond"), "fond de l'interface : promethee ou terminal", "cmd_theme"),
+    Commande("/sauver", ("save", "enregistrer"), "exporter la conversation en Markdown", "cmd_save"),
+    Commande("/quitter", ("exit", "quit", "bye", "q"), "quitter Prométhée", "cmd_quitter"),
+]
+MENU_ROWS = 8
+
+
+def find_command(name: str) -> Commande | None:
+    """La commande intégrée qui porte ce nom ou cet alias (sans la barre), ou None."""
+    return next((c for c in COMMANDS if name == c.nom[1:] or name in c.alias), None)
+
+
+def builtin_command_names() -> set[str]:
+    return {c.nom[1:] for c in COMMANDS} | {a for c in COMMANDS for a in c.alias}
+
+
+def parse_command_file(text: str, path: Path, scope: str = "global") -> dict | None:
+    """En-tête optionnel (description, argument) puis le texte envoyé à Prométhée."""
+    meta: dict[str, str] = {}
+    body = text.lstrip("\ufeff")  # BOM éventuel
+    match = re.match(r"\s*---[ \t]*\r?\n(.*?)\r?\n---[ \t]*(?:\r?\n|$)(.*)$", body, re.S)
+    if match:
+        for line in match.group(1).splitlines():
+            key, sep, value = line.partition(":")
+            if sep:
+                meta[key.strip().lower()] = value.strip().strip("\"'")
+        body = match.group(2)
+    name = agent_slug(meta.get("nom") or meta.get("name") or path.stem)
+    prompt = body.strip()
+    if not name or not prompt:
+        return None
+    return {"name": name, "description": meta.get("description", ""),
+            "argument": meta.get("argument") or meta.get("argument-hint") or "", "prompt": prompt,
+            "scope": scope, "path": path}
+
+
+def command_markdown(command: dict) -> str:
+    lines = ["---", f"description: {' '.join(command['description'].split())}"]
+    if command.get("argument"):
+        lines.append(f"argument: {command['argument']}")
+    return "\n".join(lines) + "\n---\n\n" + command["prompt"].strip() + "\n"
+
+
+def list_custom_commands(cwd: Path) -> list[dict]:
+    """Commandes globales puis celles du dossier (même nom : celle du dossier gagne). Les noms des commandes
+    intégrées (/aide, /clear…) restent réservés."""
+    found: dict[str, dict] = {}
+    folders = [("global", COMMANDS_DIR)]
+    local = cwd / LOCAL_COMMANDS
+    if os.path.normcase(str(local)) != os.path.normcase(str(COMMANDS_DIR)):
+        folders.append(("dossier", local))
+    reserved = builtin_command_names()
+    for scope, folder in folders:
+        try:
+            files = sorted(folder.glob("*.md"))
+        except OSError:
+            continue
+        for path in files:
+            try:
+                command = parse_command_file(read_text_file(path)[0], path, scope)
+            except (OSError, ValueError):
+                continue
+            if command and command["name"] not in reserved:
+                found[command["name"]] = command
+    return list(found.values())
+
+
+def find_custom_command(name: str, cwd: Path) -> dict | None:
+    slug = agent_slug(name)
+    return next((c for c in list_custom_commands(cwd) if c["name"] == slug), None)
+
+
+def expand_command(command: dict, args: str) -> str:
+    """$ARGUMENTS = tout ce qui suit /nom ; $1, $2… = ses mots (les guillemets groupent)."""
+    text = command["prompt"]
+    words = [a or b for a, b in re.findall(r'"([^"]*)"|(\S+)', args)]
+    text = re.sub(r"\$([1-9])", lambda m: words[int(m.group(1)) - 1] if int(m.group(1)) <= len(words) else "", text)
+    if "$ARGUMENTS" in text:
+        return text.replace("$ARGUMENTS", args.strip())
+    return text + (f"\n\n{args.strip()}" if args.strip() else "")
+
+
+# --------------------------------------------------------------------------- /init : mémoire du dossier
+INIT_PROMPT = """Analyse le dossier courant ({cwd}) pour écrire sa mémoire : le fichier {path} (comme CLAUDE.md pour Claude Code), que tu reliras à chaque conversation dans ce dossier.
+1. Liste ses fichiers avec chercher_fichiers (motif *), seul, et attends son résultat avant de lire quoi que ce soit.
+2. Ensuite, lis avec lire_fichier les 5 fichiers les plus utiles DE CETTE LISTE (documentation, notes, scripts), en recopiant exactement leur chemin. Ne lis aucun fichier qui n'y figure pas.
+3. Écris {path} avec ecrire_fichier : un titre, puis des puces courtes : à quoi sert ce dossier, ses fichiers et sous-dossiers importants (seulement ceux de la liste), les commandes ou outils qui apparaissent dans les fichiers lus, et les précautions qu'ils mentionnent. Rien d'inventé : pas de fichier, de commande ni de conseil général qui ne viennent pas de ce que tu as lu.{existing}"""
+INIT_EXISTING = ("\nCe fichier existe déjà : lis-le d'abord, puis complète-le avec modifier_fichier, sans supprimer ce que "
+                 "l'utilisateur y a écrit.")
+

package/tui/promethee/completion.py

@@ -0,0 +1,140 @@
+"""Menus d'autocomplétion ( / et @ ) et fichiers joints avec @chemin."""
+from __future__ import annotations
+
+import os
+import re
+from pathlib import Path
+
+from .agents import list_agents
+from .commandes import COMMANDS, list_custom_commands
+from .fichiers import read_text_file, resolve_path, show_path
+
+
+def command_completions(typed: str) -> list[tuple[str, str, str]]:
+    """(texte à insérer, libellé, description) des commandes qui commencent par ce qui est tapé."""
+    word = typed[1:].lower()
+    return [(c.nom, c.nom, c.description) for c in COMMANDS
+            if c.nom[1:].startswith(word) or any(a.startswith(word) for a in c.alias)]
+
+
+def custom_command_completions(typed: str, cwd: Path) -> list[tuple[str, str, str]]:
+    word = typed[1:].lower()
+    items = []
+    for command in list_custom_commands(cwd):
+        if command["name"].startswith(word):
+            label = f"/{command['name']}" + (f" {command['argument']}" if command.get("argument") else "")
+            desc = " ".join(command["description"].split())
+            items.append((f"/{command['name']}", label, "perso · " + (desc[:70] + "…" if len(desc) > 70 else desc)))
+    return items
+
+
+AT_TOKEN = re.compile(r'(?:^|(?<=\s))@("[^"]*|[^\s"]*)$')  # « @chemin » en cours de frappe, juste avant le curseur
+
+
+def human_size(n: int) -> str:
+    if n < 1024:
+        return f"{n} o"
+    if n < 1024 ** 2:
+        return f"{n / 1024:.0f} Ko"
+    return f"{n / 1024 ** 2:.1f} Mo"
+
+
+def file_completions(token: str, cwd: Path, limit: int = 40) -> list[tuple[str, str, str]]:
+    raw = token.lstrip('"').replace("/", "\\")
+    folder, _, prefix = raw.rpartition("\\")
+    base = resolve_path(folder + "\\", cwd) if folder else cwd
+    entries = []
+    try:
+        with os.scandir(base) as it:
+            for i, entry in enumerate(it):
+                if i > 3000:
+                    break
+                name = entry.name
+                if not name.lower().startswith(prefix.lower()) or (name.startswith(".") and not prefix.startswith(".")):
+                    continue
+                try:
+                    is_dir = entry.is_dir()
+                except OSError:
+                    continue
+                entries.append((not is_dir, name.lower(), name, is_dir, entry))
+    except OSError:
+        return []
+    items = []
+    for _, _, name, is_dir, entry in sorted(entries)[:limit]:
+        value = (folder + "\\" if folder else "") + name + ("\\" if is_dir else "")
+        if is_dir:
+            desc = "dossier"
+        else:
+            try:
+                desc = human_size(entry.stat().st_size)
+            except OSError:
+                desc = ""
+        if " " in value:  # chemin avec espaces : entre guillemets (laissés ouverts pour un dossier)
+            value = f'"{value}' if is_dir else f'"{value}"'
+        items.append((value, "@" + value.strip('"'), desc))
+    return items
+
+
+def agent_completions(token: str, cwd: Path) -> list[tuple[str, str, str]]:
+    """Agents proposés en tête du menu « @ » (comme @agent-… dans Claude Code)."""
+    typed = token.lower()
+    if '"' in typed or "\\" in typed:
+        return []
+    items = []
+    for agent in list_agents(cwd):
+        value = f"agent-{agent['name']}"
+        if value.startswith(typed):
+            desc = " ".join(agent["description"].split())
+            items.append((value, "@" + value, "agent · " + (desc[:70] + "…" if len(desc) > 70 else desc)))
+    return items
+
+
+# --------------------------------------------------------------------------- Fichiers joints avec @chemin
+AT_REF = re.compile(r'(?:^|(?<=\s))@(?:"([^"]+)"?|([^\s"]+))')
+MAX_ATTACH_CHARS = 8000
+
+
+def expand_attachments(text: str, cwd: Path) -> tuple[str, list[tuple[str, str, bool]]]:
+    """Ajoute au message le contenu des fichiers cités avec @chemin.
+    Renvoie (texte pour le modèle, [(chemin affiché, résumé, réussi)])."""
+    blocks: list[str] = []
+    notes: list[tuple[str, str, bool]] = []
+    seen: set[str] = set()
+    for match in AT_REF.finditer(text):
+        raw = (match.group(1) or match.group(2) or "").strip()
+        path = resolve_path(raw, cwd)
+        if not path.exists():  # « regarde @log.txt, stp » : ponctuation collée
+            path = resolve_path(raw.rstrip(",.;:!?)»'"), cwd)
+        if not path.exists():
+            if re.search(r"[.\\/]", raw):
+                notes.append((raw, "introuvable, non joint", False))
+            continue
+        key = os.path.normcase(str(path))
+        if key in seen:
+            continue
+        seen.add(key)
+        shown = show_path(path, cwd)
+        if path.is_dir():
+            try:
+                names = sorted(e.name + ("\\" if e.is_dir() else "") for e in os.scandir(path))
+            except OSError as err:
+                notes.append((shown, f"illisible ({err})", False))
+                continue
+            blocks.append(f"[Contenu du dossier {path} : {len(names)} éléments]\n" + "\n".join(names[:200])
+                          + ("\n[…]" if len(names) > 200 else ""))
+            notes.append((shown, f"{len(names)} éléments listés", True))
+            continue
+        try:
+            content = read_text_file(path)[0]
+        except (OSError, ValueError) as err:
+            notes.append((shown, f"non joint : {err}", False))
+            continue
+        n = content.count("\n") + (0 if content.endswith("\n") or not content else 1)
+        if len(content) > MAX_ATTACH_CHARS:
+            content = (content[:MAX_ATTACH_CHARS] + f"\n[… coupé : {n} lignes au total. Pour la suite, utilise "
+                       "lire_fichier avec debut et fin …]")
+        blocks.append(f"[Fichier joint : {path}]\n```\n{content.rstrip()}\n```")
+        notes.append((shown, f"{n} ligne{'s' if n > 1 else ''}", True))
+    if not blocks:
+        return text, notes
+    return text + "\n\n" + "\n\n".join(blocks), notes

package/tui/promethee/config.py

@@ -0,0 +1,12 @@
+"""Réglages fixes de la TUI : modèle par défaut, dossier de données, limites d'exécution."""
+from __future__ import annotations
+
+from pathlib import Path
+
+DEFAULT_MODEL = "promethee"
+SAVE_DIR = Path.home() / "Documents" / "Promethee"
+
+MAX_STEPS = 12              # nombre max d'allers-retours modèle -> commande par message (audit ≈ 6-8)
+CMD_TIMEOUT = 300           # secondes avant d'arrêter une commande bloquée
+MAX_TOOL_CHARS = 3500       # taille max d'une sortie renvoyée au modèle
+CREATE_NO_WINDOW = 0x08000000