@nosserb/prmt 0.0.0-stage → 2.0.0

package/tui/promethee/app/contexte.py

@@ -0,0 +1,188 @@
+"""/contexte, /code, retour en arrière (Esc Esc) et /init."""
+from __future__ import annotations
+
+import json
+import os
+
+from rich.text import Text
+from textual import work
+from textual.widgets import Markdown, Static
+
+from ..agents import agents_guide, list_agents
+from ..commandes import INIT_EXISTING, INIT_PROMPT
+from ..consignes import TOOL_GUIDE
+from ..conversation import AUTO_COMPACT_PCT
+from ..memoire import GLOBAL_MEMORY, MEMORY_NAME
+from ..shell import SHELL_TAG
+from ..ollama import OLLAMA
+from ..theme import CODE_COLOR, DIM, GREEN, RED, YELLOW
+
+
+class Contexte:
+    """Partie de PrometheeApp : /contexte, /code, retour en arrière (Esc Esc) et /init."""
+
+    # ------------------------------------------------------------------ /contexte
+    def context_breakdown(self) -> list[tuple[str, int]]:
+        """Ce qui occupe le contexte, en jetons estimés (≈ 3 caractères par jeton)."""
+        def tokens(chars: int) -> int:
+            return round(chars / 3.0)
+
+        parts: list[tuple[str, int]] = [("Consignes du modèle (Modelfile)", tokens(len(self.model_system or "")))]
+        if self.supports_tools:
+            parts.append(("Guide des outils", tokens(len(TOOL_GUIDE.format(cwd=self.cwd, date="00/00/0000")))))
+            agents = list_agents(self.cwd)
+            if agents:
+                parts.append((f"Agents ({len(agents)})", tokens(len(agents_guide(agents)))))
+            parts.append(("Définitions des outils", 1250))
+        memory = self.memory_text()
+        if memory:
+            parts.append(("Mémoire (PROMETHEE.md)", tokens(len(memory))))
+        if self.summary:
+            parts.append(("Résumé (compactage)", tokens(len(self.summary) + 60)))
+        asked = answers = outputs = attached = 0
+        for m in self.messages:
+            content = str(m.get("content") or "")
+            if m["role"] == "user":
+                if content.startswith(SHELL_TAG):
+                    outputs += len(content)
+                else:
+                    shown = len(m.get("display") or content)
+                    asked += min(shown, len(content))
+                    attached += max(0, len(content) - shown)
+            elif m["role"] == "assistant":
+                answers += len(content) + (len(json.dumps(m["tool_calls"], ensure_ascii=False)) if m.get("tool_calls") else 0)
+            else:
+                outputs += len(content)
+        parts += [("Tes messages", tokens(asked)), ("Fichiers joints (@)", tokens(attached)),
+                  ("Réponses de Prométhée", tokens(answers)), ("Sorties des outils et rapports d'agents", tokens(outputs))]
+        return [(label, n) for label, n in parts if n]
+
+    def cmd_context(self, arg: str = "") -> None:
+        parts = self.context_breakdown()
+        total = sum(n for _, n in parts)
+        used = max(total, self.ctx_used)
+        limit = self.num_ctx or 0
+        rows = "\n".join(f"| {label} | {n:,} | {100 * n / limit:.0f} % |".replace(",", " ") if limit
+                         else f"| {label} | {n:,} | |".replace(",", " ") for label, n in parts)
+        bar = ""
+        if limit:
+            pct = min(100, round(100 * used / limit))
+            filled = round(pct / 5)
+            bar = f"`{'█' * filled}{'░' * (20 - filled)}` **{pct} %** de {limit:,} jetons".replace(",", " ")
+        tips = ("\n\n*Le contexte est la mémoire de travail du modèle. Au-delà de "
+                f"{AUTO_COMPACT_PCT} %, la conversation est compactée automatiquement ; `/compact` pour le faire maintenant, "
+                "`/clear` pour repartir de zéro. Les agents travaillent dans leur propre contexte : leurs longues sorties "
+                "n'arrivent pas ici, seulement leur rapport.*")
+        self.add_notice_md(f"**Contexte** {bar}\n\n| Contenu | Jetons (≈) | Part |\n|---|---:|---:|\n{rows}"
+                           f"\n| **Total estimé** | **{total:,}** | |".replace(",", " ") + tips)
+
+    # ------------------------------------------------------------------ /code : IA de code
+    def cmd_code(self, arg: str = "") -> None:
+        word = arg.strip()
+        if word.lower() in ("off", "non", "stop"):
+            self.code_auto = False
+            self.add_notice("Bascule automatique coupée : Prométhée répond à tout, code compris. /code on pour la "
+                            "rétablir.")
+        elif word.lower() in ("on", "oui"):
+            self.code_auto = True
+            self.add_notice(f"Bascule automatique activée : les demandes de programmation vont à {self.code_model}.",
+                            CODE_COLOR)
+        elif word:
+            self.set_code_model(word)
+        else:
+            state = "activée" if self.code_auto else "coupée (/code on pour l'activer)"
+            self.add_notice_md(
+                f"**IA de code** : `{self.code_model}` · bascule automatique **{state}**\n\n"
+                "Quand tu demandes d'écrire, corriger ou expliquer du code, l'interpréteur le détecte et confie la "
+                "réponse à l'IA de code (même conversation, mêmes outils, tu valides toujours chaque commande). "
+                "Prométhée reprend la main au message suivant. Un changement de modèle prend quelques secondes "
+                "(chargement dans la carte graphique).\n\n"
+                "`/code off` · `/code on` · `/code <modèle>` pour en choisir un autre (il doit savoir utiliser des outils).")
+
+    @work(thread=True, exclusive=True, group="model")
+    def set_code_model(self, name: str) -> None:
+        name = name[:-7] if name.endswith(":latest") else name
+        self._caps.pop(name, None)
+        caps = self.model_caps(name)
+        if caps is None and name not in self._caps:
+            self.call_from_thread(self.add_notice, f"Ollama ne répond pas sur {OLLAMA} : impossible de vérifier « {name} ». "
+                                  "Lance l'application Ollama puis réessaie.", f"bold {RED}")
+        elif caps is None:
+            self.call_from_thread(self.add_notice, f"Modèle « {name} » introuvable. /modele pour voir la liste.", f"bold {RED}")
+        elif "tools" not in caps:
+            self.call_from_thread(self.add_notice, f"« {name} » ne sait pas utiliser d'outils : il ne pourrait ni écrire "
+                                  "de fichier ni compiler. Choisis-en un autre.", YELLOW)
+        else:
+            self.code_model, self.code_auto, self._code_warned = name, True, False
+            self.call_from_thread(self.add_notice, f"IA de code : {name}.", CODE_COLOR)
+
+    # ------------------------------------------------------------------ Esc Esc : revenir en arrière
+    def open_rewind(self) -> None:
+        """Comme Claude Code : choisir un de ses messages ; la conversation repart juste avant, message à modifier."""
+        points = [(i, " ".join((m.get("display") or m["content"]).split())) for i, m in enumerate(self.messages)
+                  if m["role"] == "user" and not str(m.get("content") or "").startswith(SHELL_TAG)]
+        if not points:
+            self.notify("Aucun message auquel revenir.", timeout=2)
+            return
+        points = points[-9:][::-1]
+        options = []
+        for k, (i, text) in enumerate(points):
+            later = sum(1 for m in self.messages[i:] if m["role"] == "user")
+            when = "ton dernier message" if k == 0 else f"il y a {later} messages"
+            options.append((str(i), f"{text[:70] + '…' if len(text) > 70 else text}   ({when})"))
+        options.append(("no", "Annuler (Esc)"))
+        body = Text("  La conversation reprendra juste avant le message choisi, qui revient dans la saisie pour que tu "
+                    "le modifies.\n  Les commandes déjà exécutées et les fichiers déjà modifiés ne sont pas annulés.",
+                    style=DIM)
+
+        def chosen(decision: str) -> None:
+            if decision.isdigit():
+                self.run_worker(self.rewind_to(int(decision)), exclusive=False)
+
+        self.ask("Revenir en arrière", body, "Reprendre avant quel message ?", options, chosen)
+
+    async def rewind_to(self, index: int) -> None:
+        if self.generating or index >= len(self.messages):
+            return
+        message = self.messages[index]
+        text = message.get("display") or message["content"]
+        self.messages = self.messages[:index]
+        self.tasks = []
+        self.render_tasks()
+        self.last_answer = next((m["content"] for m in reversed(self.messages)
+                                 if m["role"] == "assistant" and (m.get("content") or "").strip()), "")
+        await self.rebuild_chat()
+        self.add_notice("Conversation reprise avant ce message : modifie-le puis Entrée pour le renvoyer.", GREEN)
+        self.input.load_text(text)
+        self.input.move_cursor(self.input.document.end)
+        self.ctx_used = self.estimate_tokens()
+        self.update_status()
+        self.save_session()
+
+    async def rebuild_chat(self) -> None:
+        """Réaffiche toute la conversation à partir des messages (reprise, retour en arrière)."""
+        await self.chat.remove_children()
+        await self.chat.mount_all(list(self._welcome_widgets()))
+        if self.summary:
+            await self.chat.mount(Static(Text.assemble(("⎿  ", DIM), ("Début de la conversation compacté. Résumé :", DIM)),
+                                         classes="notice"))
+            await self.chat.mount(Markdown(self.summary, classes="notice-md"))
+        await self.chat.mount_all(self._replay_widgets())
+        self.chat.scroll_end(animate=False)
+        self.call_after_refresh(self._follow)
+
+    # ------------------------------------------------------------------ /init
+    def cmd_init(self, arg: str = "") -> None:
+        if self.generating:
+            self.add_notice("Attends la fin de la réponse (ou Esc pour l'interrompre).", YELLOW)
+            return
+        if not self.supports_tools:
+            self.add_notice("Ce modèle ne sait pas utiliser les outils : /init a besoin de lire le dossier.", YELLOW)
+            return
+        path = self.cwd / MEMORY_NAME
+        if os.path.normcase(str(path)) == os.path.normcase(str(GLOBAL_MEMORY)):
+            self.add_notice("Ici, PROMETHEE.md est la mémoire globale : lance /init dans le dossier d'un projet "
+                            "(cd dans ce dossier avec ! cd chemin).", YELLOW)
+            return
+        prompt = INIT_PROMPT.format(cwd=self.cwd, path=path, existing=INIT_EXISTING if path.exists() else "")
+        self.send_message("/init", prompt, intent=prompt, mode="action")