@nosserb/prmt 0.0.0-stage → 2.0.0

package/tui/promethee/app/definitions.py

@@ -0,0 +1,518 @@
+"""/agents et /commandes : lister, voir, créer (à la main ou décrits à Prométhée), modifier, supprimer.
+
+Un agent et une commande personnalisée sont tous deux un fichier Markdown que tu peux écrire toi-même ou
+faire écrire par Prométhée. Leurs écrans suivent le même déroulé : il est écrit une fois, dans Definitions.
+Ce qui les distingue (libellés, champs, façon de s'en servir) est décrit par un « genre » : AGENTS, COMMANDES.
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+from pathlib import Path
+
+from rich.text import Text
+from textual import work
+
+from ..agents import (
+    AGENTS_DIR, AGENT_GEN_FIX, AGENT_GEN_SYSTEM, AGENT_SCHEMA, AGENT_TEMPLATE, AGENT_TOOL_NAMES, LOCAL_AGENTS,
+    SCOPE_LABELS, TOOL_LABELS, agent_command_problems, agent_markdown, agent_slug, find_agent, list_agents,
+    unique_agent_path,
+)
+from ..commandes import (
+    COMMANDS_DIR, COMMAND_GEN_SYSTEM, COMMAND_SCHEMA, COMMAND_TEMPLATE, LOCAL_COMMANDS, builtin_command_names,
+    command_markdown, find_custom_command, list_custom_commands,
+)
+from ..config import CREATE_NO_WINDOW
+from ..consignes import READ_TOOL, TOOL_NAME
+from ..fichiers import new_file_format, write_text_file
+from ..theme import AGENT_COLOR, DIM, GREEN, RED, YELLOW
+
+CREER = ("creer", "nouveau", "new", "create", "ajouter")
+APERCU_LIGNES = 14   # lignes de consignes montrées avant de créer
+
+
+def portee(item: dict) -> str:
+    return SCOPE_LABELS.get(item["scope"], item["scope"])
+
+
+def resume(item: dict) -> str:
+    return " ".join(item["description"].split())
+
+
+# --------------------------------------------------------------------------- genres
+class Genre:
+    """Ce qui distingue un agent d'une commande personnalisée dans les écrans de gestion."""
+
+    cle = ""                 # « agent » ou « commande » (valeur de _draft_kind)
+    dossier: Path            # définitions globales
+    local: Path              # définitions d'un dossier, relatif au dossier courant
+    schema: dict = {}        # forme de la réponse demandée au modèle
+    consigne = ""            # consigne de génération
+    jetons = 0               # longueur maximale de la réponse
+    ferme_menu = False       # après « l'utiliser », fermer le menu d'autocomplétion (une commande commence par /)
+    # Libellés (le genre grammatical change d'un genre à l'autre)
+    occupe = inconnu = titre = nouveau = titre_creation = ou_global = ou_dossier = ou_lieux = comment = decrire = ""
+    question = oui = oui_modifier = non_cree = annulee = impossible = demande = sans_texte = verification = ""
+    correction: str | None = None   # texte du spinner pendant la correction (None : pas de changement de texte)
+    invite = ""              # ce qui s'affiche quand tu vas décrire la définition à créer
+
+    def lister(self, cwd: Path) -> list[dict]:
+        raise NotImplementedError
+
+    def trouver(self, nom: str, cwd: Path) -> dict | None:
+        raise NotImplementedError
+
+    def markdown(self, item: dict) -> str:
+        raise NotImplementedError
+
+
+class GenreAgent(Genre):
+    cle, dossier, local = "agent", AGENTS_DIR, LOCAL_AGENTS
+    schema, consigne, jetons = AGENT_SCHEMA, AGENT_GEN_SYSTEM, 1000
+    occupe = "Attends la fin de la réponse avant de gérer les agents (ou Esc pour l'interrompre)."
+    inconnu = "Agent inconnu : {arg}."
+    titre, nouveau, titre_creation = "Agents", "Créer un nouvel agent", "Nouvel agent"
+    ou_global = "Agent global : disponible partout"
+    ou_dossier = "Agent de ce dossier : seulement quand tu travailles dans {dossier}"
+    ou_lieux = "  global : {globaux}\n  ce dossier : {local}"
+    comment, decrire = "Comment le créer ?", "Le décrire : Prométhée écrit l'agent pour toi (recommandé)"
+    question, oui, oui_modifier = "Créer cet agent ?", "Oui, le créer", "Oui, puis le modifier dans le Bloc-notes"
+    non_cree, annulee = "Agent non créé.", "Création de l'agent annulée."
+    impossible = "Impossible de créer l'agent : {error}. Réessaie (/agents) ou écris-le toi-même."
+    demande = "Description de l'agent voulu : « {description} »"
+    sans_texte = "le modèle n'a pas écrit de consignes"
+    verification, correction = "Vérification des commandes de l'agent", "Prométhée corrige l'agent"
+    invite = ("Décris l'agent à créer : son rôle, ce qu'il doit faire et quand l'utiliser. Par exemple : "
+              "« un agent qui audite le pare-feu Windows et liste les règles trop permissives ».")
+
+    def lister(self, cwd: Path) -> list[dict]:
+        return list_agents(cwd)
+
+    def trouver(self, nom: str, cwd: Path) -> dict | None:
+        return find_agent(nom, cwd)
+
+    def markdown(self, item: dict) -> str:
+        return agent_markdown(item)
+
+    def entete(self, items: list[dict], cwd: Path) -> Text:
+        return Text.assemble((f"  {len(items)} agent{'s' if len(items) > 1 else ''}", "bold"),
+                             (" · tape @agent-nom pour confier une tâche à un agent\n", DIM),
+                             (f"  globaux : {AGENTS_DIR}\n  de ce dossier : {cwd / LOCAL_AGENTS}", DIM))
+
+    def ligne(self, item: dict) -> str:
+        desc = resume(item)
+        return f"{item['name']}  ·  {portee(item)}  ·  {desc[:60] + '…' if len(desc) > 60 else desc}"
+
+    def titre_fiche(self, item: dict) -> str:
+        return f"Agent {item['name']}"
+
+    def fiche(self, item: dict) -> Text:
+        path = item.get("path")
+        body = Text()
+        body.append(f"  {resume(item) or '(sans description)'}\n", style=DIM)
+        body.append(f"  outils : {', '.join(TOOL_LABELS.get(t, t) for t in item['tools'])}", style=DIM)
+        if item.get("model"):
+            body.append(f"\n  modèle : {item['model']}", style=DIM)
+        body.append(f"\n  fichier : {path}" if path else "\n  agent intégré à Prométhée", style=DIM)
+        return body
+
+    def options(self, item: dict) -> list[tuple[str, str]]:
+        options = [("use", f"L'utiliser : écrire @agent-{item['name']} dans la saisie"), ("show", "Voir ses consignes")]
+        if item.get("path"):
+            options += [("edit", "Le modifier dans le Bloc-notes"), ("delete", "Le supprimer")]
+        else:
+            options.append(("copy", "Le personnaliser (copie modifiable dans tes agents globaux)"))
+        return options + [("back", "Retour à la liste"), ("no", "Fermer (Esc)")]
+
+    def saisie(self, item: dict) -> str:
+        return f"@agent-{item['name']} "
+
+    def montrer(self, item: dict) -> str:
+        tools = ", ".join(f"`{t}`" for t in item["tools"])
+        return (f"**Agent {item['name']}** ({portee(item)})\n\n*{resume(item)}*\n\nOutils : {tools}\n\n"
+                f"```text\n{item['prompt']}\n```")
+
+    def ouvert(self, item: dict) -> str:
+        return f"Agent {item['name']} ouvert dans le Bloc-notes. Les changements comptent dès sa prochaine utilisation."
+
+    def suppression(self, item: dict) -> tuple[str, str]:
+        return "Supprimer un agent", f"Supprimer l'agent {item['name']} ?"
+
+    def supprime(self, item: dict, cwd: Path) -> str:
+        back = find_agent(item["name"], cwd)
+        return f"Agent {item['name']} supprimé ({item['path']})." + (
+            " L'agent intégré du même nom est de nouveau utilisé." if back and back["scope"] == "intégré" else "")
+
+    def gabarit(self, name: str) -> tuple[str, str]:
+        """(contenu du modèle prérempli, message une fois le fichier ouvert). {path} est remplacé par le chemin."""
+        return agent_markdown(dict(AGENT_TEMPLATE, name=name)), (
+            "Modèle d'agent créé ({path}). Remplis-le dans le Bloc-notes (nom, description, outils, consignes) puis "
+            "enregistre : il sera disponible tout de suite.")
+
+    gabarit_nom = AGENT_TEMPLATE["name"]
+
+    def construire(self, data: dict, prompt: str, scope: str) -> dict:
+        return {"name": agent_slug(str(data.get("nom") or "")) or "mon-agent", "description": " ".join(str(data.get("description") or "").split()),
+                "tools": [t for t in AGENT_TOOL_NAMES if t in (data.get("outils") or [])] or [TOOL_NAME, READ_TOOL],
+                "model": "", "prompt": prompt, "scope": scope, "path": None, "warnings": []}
+
+    def nom_libre(self, item: dict, folder: Path) -> tuple[str, Path]:
+        return unique_agent_path(folder, item["name"])
+
+    def apercu(self, item: dict) -> Text:
+        body = Text()
+        body.append(f"  @agent-{item['name']}\n", style=f"bold {AGENT_COLOR}")
+        body.append(f"  {item['description']}\n", style=DIM)
+        body.append(f"  outils : {', '.join(TOOL_LABELS.get(t, t) for t in item['tools'])}\n\n", style=DIM)
+        return body
+
+    def cree(self, item: dict, edit: bool) -> str:
+        name = item["name"]
+        if edit:
+            return f"Agent {name} créé et ouvert dans le Bloc-notes. Utilise-le avec @agent-{name}."
+        return (f"Agent {name} créé ({item['path']}). Utilise-le avec @agent-{name} ou demande à Prométhée "
+                "de lui confier une tâche.")
+
+
+class GenreCommande(Genre):
+    cle, dossier, local = "commande", COMMANDS_DIR, LOCAL_COMMANDS
+    schema, consigne, jetons = COMMAND_SCHEMA, COMMAND_GEN_SYSTEM, 800
+    ferme_menu = True
+    occupe = "Attends la fin de la réponse avant de gérer les commandes (ou Esc pour l'interrompre)."
+    inconnu = "Commande personnalisée inconnue : {arg}."
+    titre, nouveau, titre_creation = "Commandes personnalisées", "Créer une nouvelle commande", "Nouvelle commande"
+    ou_global = "Commande globale : disponible partout"
+    ou_dossier = "Commande de ce dossier : seulement quand tu travailles dans {dossier}"
+    ou_lieux = "  globales : {globaux}\n  ce dossier : {local}"
+    comment, decrire = "Comment la créer ?", "La décrire : Prométhée l'écrit pour toi (recommandé)"
+    question, oui, oui_modifier = "Créer cette commande ?", "Oui, la créer", "Oui, puis la modifier dans le Bloc-notes"
+    non_cree, annulee = "Commande non créée.", "Création de la commande annulée."
+    impossible = "Impossible de créer la commande : {error}. Réessaie (/commandes) ou écris-la toi-même."
+    demande = "Description de la commande voulue : « {description} »"
+    sans_texte = "le modèle n'a pas écrit le texte de la commande"
+    verification = "Vérification des commandes citées"
+    invite = ("Décris la commande à créer : ce qu'elle doit faire et ce que tu tapes après son nom. Par "
+              "exemple : « une commande qui scanne les ports courants d'une adresse IP et explique "
+              "chaque service trouvé ».")
+
+    def lister(self, cwd: Path) -> list[dict]:
+        return list_custom_commands(cwd)
+
+    def trouver(self, nom: str, cwd: Path) -> dict | None:
+        return find_custom_command(nom.lstrip("/"), cwd)
+
+    def markdown(self, item: dict) -> str:
+        return command_markdown(item)
+
+    @staticmethod
+    def usage(item: dict) -> str:
+        return f"/{item['name']}" + (f" {item['argument']}" if item.get("argument") else "")
+
+    def entete(self, items: list[dict], cwd: Path) -> Text:
+        s = "s" if len(items) > 1 else ""
+        return Text.assemble((f"  {len(items)} commande{s} personnalisée{s}", "bold"),
+                             (" · tape /nom pour en lancer une (elles apparaissent dans le menu /)\n", DIM),
+                             (f"  globales : {COMMANDS_DIR}\n  de ce dossier : {cwd / LOCAL_COMMANDS}", DIM))
+
+    def ligne(self, item: dict) -> str:
+        desc = resume(item)
+        return f"/{item['name']}  ·  {portee(item)}  ·  {desc[:60] + '…' if len(desc) > 60 else desc}"
+
+    def titre_fiche(self, item: dict) -> str:
+        return f"Commande /{item['name']}"
+
+    def fiche(self, item: dict) -> Text:
+        body = Text()
+        body.append(f"  {self.usage(item)}\n", style=f"bold {AGENT_COLOR}")
+        body.append(f"  {resume(item) or '(sans description)'}\n", style=DIM)
+        body.append(f"  fichier : {item['path']}", style=DIM)
+        return body
+
+    def options(self, item: dict) -> list[tuple[str, str]]:
+        return [("use", f"L'utiliser : écrire /{item['name']} dans la saisie"), ("show", "Voir son texte"),
+                ("edit", "La modifier dans le Bloc-notes"), ("delete", "La supprimer"), ("back", "Retour à la liste"),
+                ("no", "Fermer (Esc)")]
+
+    def saisie(self, item: dict) -> str:
+        return f"/{item['name']} "
+
+    def montrer(self, item: dict) -> str:
+        return (f"**Commande {self.usage(item)}** ({portee(item)})\n\n*{resume(item)}*\n\n"
+                f"```text\n{item['prompt']}\n```")
+
+    def ouvert(self, item: dict) -> str:
+        return f"Commande /{item['name']} ouverte dans le Bloc-notes. Les changements comptent dès sa prochaine utilisation."
+
+    def suppression(self, item: dict) -> tuple[str, str]:
+        return "Supprimer", f"Supprimer la commande /{item['name']} ?"
+
+    def supprime(self, item: dict, cwd: Path) -> str:
+        return f"La commande /{item['name']} : supprimée ({item['path']})."
+
+    def gabarit(self, name: str) -> tuple[str, str]:
+        return command_markdown(COMMAND_TEMPLATE), (
+            f"Modèle de commande créé ({{path}}) : le nom du fichier est le nom de la commande (/{name}). "
+            "Écris son texte puis enregistre.")
+
+    gabarit_nom = COMMAND_TEMPLATE["name"]
+
+    def construire(self, data: dict, prompt: str, scope: str) -> dict:
+        argument = str(data.get("argument") or "").strip()
+        if argument and "$ARGUMENTS" not in prompt:
+            prompt += "\n\nCible : $ARGUMENTS"
+        return {"name": agent_slug(str(data.get("nom") or "")) or "ma-commande", "description": " ".join(str(data.get("description") or "").split()),
+                "argument": argument, "prompt": prompt, "scope": scope, "path": None, "warnings": []}
+
+    def nom_libre(self, item: dict, folder: Path) -> tuple[str, Path]:
+        name = item["name"]
+        if name in builtin_command_names():
+            name = f"{name}-perso"   # une commande personnalisée ne peut pas prendre le nom d'une commande intégrée
+        return unique_agent_path(folder, name)
+
+    def apercu(self, item: dict) -> Text:
+        body = Text()
+        body.append(f"  {self.usage(item)}\n", style=f"bold {AGENT_COLOR}")
+        body.append(f"  {item['description']}\n\n", style=DIM)
+        return body
+
+    def cree(self, item: dict, edit: bool) -> str:
+        name = item["name"]
+        if edit:
+            return f"Commande /{name} créée et ouverte dans le Bloc-notes."
+        return f"Commande /{name} créée ({item['path']}). Lance-la avec {self.usage(item)}."
+
+
+AGENTS, COMMANDES = GenreAgent(), GenreCommande()
+GENRES = {genre.cle: genre for genre in (AGENTS, COMMANDES)}
+
+
+# --------------------------------------------------------------------------- écrans
+class Definitions:
+    """Partie de PrometheeApp : /agents et /commandes : lister, créer, modifier, supprimer."""
+
+    def cmd_agents(self, arg: str = "") -> None:
+        """/agents : la liste des agents, puis créer, voir, modifier ou supprimer."""
+        self._gerer(AGENTS, arg)
+
+    def cmd_commands(self, arg: str = "") -> None:
+        """/commandes : la liste des commandes personnalisées, puis créer, voir, modifier ou supprimer."""
+        self._gerer(COMMANDES, arg)
+
+    def _gerer(self, genre: Genre, arg: str = "") -> None:
+        if self.generating:
+            self.add_notice(genre.occupe, YELLOW)
+            return
+        if arg:
+            if agent_slug(arg) in CREER:
+                self._creer(genre)
+                return
+            item = genre.trouver(arg, self.cwd)
+            if item is not None:
+                self._fiche(genre, item)
+                return
+            self.add_notice(genre.inconnu.format(arg=arg), YELLOW)
+        items = genre.lister(self.cwd)
+        options = [("new", genre.nouveau)] + [(f"i{i}", genre.ligne(item)) for i, item in enumerate(items)]
+        options.append(("no", "Fermer (Esc)"))
+
+        def chosen(decision: str) -> None:
+            if decision == "new":
+                self._creer(genre)
+            elif decision.startswith("i"):
+                self._fiche(genre, items[int(decision[1:])])
+
+        self.ask(genre.titre, genre.entete(items, self.cwd), "Que veux-tu faire ?", options, chosen, esc="fermer")
+
+    def _fiche(self, genre: Genre, item: dict) -> None:
+        """Une définition : s'en servir, voir son texte, la modifier, la supprimer."""
+        def chosen(decision: str) -> None:
+            if decision == "use":
+                self.input.load_text(genre.saisie(item))
+                self.input.move_cursor(self.input.document.end)
+                if genre.ferme_menu:
+                    self.hide_completions()
+            elif decision == "show":
+                self.add_notice_md(genre.montrer(item))
+            elif decision == "edit":
+                self.open_in_notepad(item["path"], genre.ouvert(item))
+            elif decision == "delete":
+                self._supprimer(genre, item)
+            elif decision == "copy":
+                self._personnaliser(item)
+            elif decision == "back":
+                self._gerer(genre)
+
+        self.ask(genre.titre_fiche(item), genre.fiche(item), "Que veux-tu faire ?", genre.options(item), chosen, esc="fermer")
+
+    def _personnaliser(self, agent: dict) -> None:
+        """Agent intégré : en faire une copie modifiable dans les agents globaux (elle le remplace)."""
+        name, target = agent["name"], AGENTS_DIR / f"{agent['name']}.md"
+        try:
+            if not target.exists():
+                write_text_file(target, agent_markdown(agent), *new_file_format(target))
+        except OSError as err:
+            self.add_notice(f"Impossible d'écrire {target} : {err}", f"bold {RED}")
+            return
+        self.open_in_notepad(target, f"Copie de l'agent {name} créée ({target}) : elle remplace l'agent "
+                                     "intégré. Modifie-la puis enregistre.")
+
+    def _supprimer(self, genre: Genre, item: dict) -> None:
+        path: Path = item["path"]
+
+        def chosen(decision: str) -> None:
+            if decision != "yes":
+                return
+            try:
+                path.unlink()
+            except OSError as err:
+                self.add_notice(f"Impossible de supprimer {path} : {err}", f"bold {RED}")
+                return
+            self.add_notice(genre.supprime(item, self.cwd), GREEN)
+
+        title, question = genre.suppression(item)
+        self.ask(title, Text(f"  {path}", style="bold"), question, [("yes", "Oui, supprimer ce fichier"), ("no", "Non (Esc)")],
+                 chosen, danger=True)
+
+    def open_in_notepad(self, path: Path, message: str) -> None:
+        try:
+            subprocess.Popen(["notepad.exe", str(path)], creationflags=CREATE_NO_WINDOW)
+        except OSError as err:
+            self.add_notice(f"Impossible d'ouvrir {path} : {err}", f"bold {RED}")
+            return
+        self.add_notice(message, GREEN)
+
+    # ------------------------------------------------------------------ création
+    def _dossier(self, genre: Genre, scope: str) -> Path:
+        return genre.dossier if scope == "global" else self.cwd / genre.local
+
+    def _creer(self, genre: Genre) -> None:
+        """Créer une définition : où (globale / ce dossier), puis comment (la décrire / l'écrire soi-même)."""
+        local = self.cwd / genre.local
+        options = [("global", genre.ou_global)]
+        if os.path.normcase(str(local)) != os.path.normcase(str(genre.dossier)):
+            options.append(("dossier", genre.ou_dossier.format(dossier=self.cwd.name or self.cwd)))
+        options.append(("no", "Annuler (Esc)"))
+
+        def where(decision: str) -> None:
+            if decision in ("global", "dossier"):
+                self.call_after_refresh(self._creer_comment, genre, decision)
+
+        self.ask(genre.titre_creation, Text(genre.ou_lieux.format(globaux=genre.dossier, local=local), style=DIM),
+                 "Où l'enregistrer ?", options, where)
+
+    def _creer_comment(self, genre: Genre, scope: str) -> None:
+        def how(decision: str) -> None:
+            if decision == "gen":
+                self.set_agent_draft(scope, genre.cle)
+            elif decision == "manual":
+                name, path = unique_agent_path(self._dossier(genre, scope), genre.gabarit_nom)
+                content, message = genre.gabarit(name)
+                try:
+                    write_text_file(path, content, *new_file_format(path))
+                except OSError as err:
+                    self.add_notice(f"Impossible d'écrire {path} : {err}", f"bold {RED}")
+                    return
+                self.open_in_notepad(path, message.format(path=path))
+
+        options = [("gen", genre.decrire), ("manual", "L'écrire moi-même dans le Bloc-notes (modèle prérempli)"),
+                   ("no", "Annuler (Esc)")]
+        self.ask(genre.titre_creation, None, genre.comment, options, how)
+
+    def set_agent_draft(self, scope: str | None, kind: str = "agent") -> None:
+        """En attente de la description d'un nouvel agent ou d'une nouvelle commande (la saisie devient violette)."""
+        self._agent_draft = scope
+        self._draft_kind = kind
+        self.query_one("#input-box").set_class(scope is not None, "-agent")
+        if scope is not None:
+            self.add_notice(GENRES[kind].invite, AGENT_COLOR)
+        self.set_hints()
+
+    @work(thread=True, exclusive=True, group="generate")
+    def generate_agent(self, description: str, scope: str) -> None:
+        self._generer(AGENTS, description, scope)
+
+    @work(thread=True, exclusive=True, group="generate")
+    def generate_command(self, description: str, scope: str) -> None:
+        self._generer(COMMANDES, description, scope)
+
+    def _generer(self, genre: Genre, description: str, scope: str) -> None:
+        """Fait écrire la définition par le modèle (fil de travail). Les commandes PowerShell qu'il cite sont
+        vérifiées sur la machine : si l'une est fausse, il a une occasion de corriger."""
+        payload: dict = {"model": self.model, "stream": True, "format": genre.schema,
+                         "options": {"temperature": 0.3, "num_predict": genre.jetons},
+                         "messages": [{"role": "system", "content": genre.consigne},
+                                      {"role": "user", "content": genre.demande.format(description=description)}]}
+        if self.supports_thinking:
+            payload["think"] = False
+        item, error, fixed = None, None, ""
+        try:
+            for attempt in range(2):
+                raw = self._summarize(payload) if not self.cancel_event.is_set() else ""
+                if self.cancel_event.is_set():
+                    break
+                data = json.loads(raw or "{}")
+                prompt = str(data.get("consignes") or "").strip()
+                if not prompt:
+                    if item is not None:
+                        break  # la correction a échoué : on garde la première version
+                    raise ValueError(genre.sans_texte)
+                item = genre.construire(data, prompt, scope)
+                # Les commandes qu'il cite existent-elles, avec ces paramètres ? Sinon, une demande de correction.
+                self.call_from_thread(self._spinner, True, "check", genre.verification)
+                problems = agent_command_problems(item["prompt"], self.cwd)
+                item["warnings"] = [short for short, _ in problems]
+                if not problems or attempt:
+                    break
+                if genre.correction:
+                    self.call_from_thread(self._spinner, True, "check", genre.correction)
+                payload["messages"] = payload["messages"][:2] + [
+                    {"role": "assistant", "content": raw},
+                    {"role": "user", "content": AGENT_GEN_FIX.format(problems=" ; ".join(d for _, d in problems))}]
+                fixed = ", ".join(short for short, _ in problems)
+        except Exception as err:  # JSON invalide, Ollama injoignable…
+            error = str(err)
+        if item is not None:
+            item["fixed"] = fixed
+        self.call_from_thread(self._fin_generation, genre, item, error, scope)
+
+    def _fin_generation(self, genre: Genre, item: dict | None, error: str | None, scope: str) -> None:
+        """Montre la définition écrite par le modèle : tu la crées, tu la crées puis la modifies, ou tu la refuses."""
+        self.generating = False
+        self._spinner(False)
+        if self.cancel_event.is_set():
+            self.add_notice(genre.annulee, DIM)
+            return
+        if item is None:
+            self.add_notice(genre.impossible.format(error=error), f"bold {RED}")
+            return
+        name, path = genre.nom_libre(item, self._dossier(genre, scope))
+        item.update(name=name, path=path)
+        body = genre.apercu(item)
+        lines = item["prompt"].split("\n")
+        for line in lines[:APERCU_LIGNES]:
+            body.append(f"  {line}\n")
+        if len(lines) > APERCU_LIGNES:
+            body.append(f"  … +{len(lines) - APERCU_LIGNES} lignes\n", style=f"italic {DIM}")
+        body.append(f"\n  fichier : {path}", style=DIM)
+        if item.get("fixed") and not item.get("warnings"):
+            body.append(f"\n  ✓ commandes corrigées automatiquement ({item['fixed']})", style=GREEN)
+        for warning in item.get("warnings") or []:
+            body.append(f"\n  ⚠ À vérifier : {warning}", style=YELLOW)
+
+        def chosen(decision: str) -> None:
+            if decision not in ("yes", "edit"):
+                self.add_notice(genre.non_cree, DIM)
+                return
+            try:
+                write_text_file(path, genre.markdown(item), *new_file_format(path))
+            except OSError as err:
+                self.add_notice(f"Impossible d'écrire {path} : {err}", f"bold {RED}")
+                return
+            if decision == "edit":
+                self.open_in_notepad(path, genre.cree(item, True))
+            else:
+                self.add_notice(genre.cree(item, False), GREEN)
+
+        self.ask(genre.titre_creation, body, genre.question,
+                 [("yes", genre.oui), ("edit", genre.oui_modifier), ("no", "Non (Esc)")], chosen)