@nosserb/prmt 0.0.0-stage → 2.0.0

package/tui/promethee/app/ecran.py

@@ -0,0 +1,177 @@
+"""Barre d'état, spinner et affichage dans la conversation."""
+from __future__ import annotations
+
+import random
+import time
+
+from rich.text import Text
+from textual.widgets import Markdown, Static
+
+from ..accueil import Accueil
+from ..textes import SPINNER, VERBS
+from ..theme import AGENT_COLOR, CODE_COLOR, DIM, MEMORY_COLOR, ORANGE, PLAN_COLOR, RED, SHELL_COLOR, YELLOW
+from ..widgets import AgentView, AssistantMessage, SearchView, ToolCallView
+
+
+class Ecran:
+    """Partie de PrometheeApp : barre d'état, spinner et affichage dans la conversation."""
+
+    # ------------------------------------------------------------------ barre d'état
+    def set_hints(self, text: str | None = None, warn: bool = False) -> None:
+        hints = self.query_one("#hints", Static)
+        if text:
+            hints.update(Text(text, style=f"bold {YELLOW}" if warn else DIM))
+        elif self._perm is not None:
+            hints.update(Text(self._perm.hint, style=DIM))
+        elif self._comp_items:
+            what = "lancer" if self._comp_kind == "/" else "joindre"
+            hints.update(Text(f"↑↓ choisir · Tab compléter · Entrée {what} · Esc fermer", style=DIM))
+        elif self.input.text.startswith("!"):
+            hints.update(Text("! mode commande : une lecture part directement, le reste te demande une confirmation",
+                              style=SHELL_COLOR))
+        elif self._agent_draft is not None:
+            what = ("Nouvel agent : décris son rôle et quand l'utiliser" if self._draft_kind == "agent"
+                    else "Nouvelle commande : décris ce qu'elle doit faire")
+            hints.update(Text(f"{what}, puis Entrée · Esc annuler", style=AGENT_COLOR))
+        elif self.input.text.startswith("#"):
+            hints.update(Text("# mode mémoire : Entrée enregistre cette note (mémoire globale ou du dossier)",
+                              style=MEMORY_COLOR))
+        elif self.plan_mode:
+            hints.update(Text("⏸ mode plan : Prométhée propose un plan sans rien exécuter · Shift+Tab pour quitter",
+                              style=PLAN_COLOR))
+        else:
+            hints.update(Text("/aide · Shift+Tab plan · Esc interrompre · Ctrl+C ×2 quitter", style=DIM))
+
+    def update_status(self) -> None:
+        parts = Text(style=DIM)
+        if self.generating and self._turn_model and self._turn_model != self.model:
+            parts.append(f"{self._turn_model} (code)", style=CODE_COLOR)
+        else:
+            parts.append(self.model, style=ORANGE)
+        if self.model_state:
+            parts.append(f" · {self.model_state}")
+        elif not self.supports_tools:
+            parts.append(" · sans commandes")
+        # Politique : « stricte » au repos, « souple » et « validation manuelle » signalées (un mot, pas seulement une couleur)
+        politique = self.politique
+        relaxed = politique.libelle() != "politique stricte"
+        parts.append(" · ")
+        parts.append(("▲ " if relaxed else "") + politique.libelle(), style=YELLOW if relaxed else DIM)
+        if self.num_ctx:
+            pct = min(100, round(100 * self.ctx_used / self.num_ctx))
+            style = f"bold {RED}" if pct >= 90 else YELLOW if pct >= 75 else DIM
+            parts.append(" · ")
+            if self.size.width >= 132:
+                filled = min(8, round(8 * pct / 100))
+                parts.append("▰" * filled, style=RED if pct >= 90 else YELLOW if pct >= 75 else ORANGE)
+                parts.append("▱" * (8 - filled) + " ", style=DIM)
+            parts.append(f"contexte {pct} %", style=style)
+            if pct >= 90:
+                parts.append(" (/compact conseillé)", style=f"bold {RED}")
+        if self.last_tps:
+            parts.append(f" · {self.last_tps:.0f} tok/s")
+        self.query_one("#status", Static).update(parts)
+        for panel in self.query(Accueil):
+            panel.rafraichir()   # l'accueil montre le même état : modèle, politique
+
+    def _tick_spinner(self) -> None:
+        if not self.generating or self._perm is not None:
+            return
+        self._follow()
+        now = time.monotonic()
+        frame = SPINNER[int(now * 8) % len(SPINNER)]
+        elapsed = int(now - self.spin_start)
+        if self.spin_mode == "command":
+            verb, detail, stop = "Exécution de la commande", f"{elapsed}s", "Esc pour l'arrêter"
+        elif self.spin_mode == "check":
+            verb, detail, stop = self.spin_verb, f"{elapsed}s", "Esc pour interrompre"
+        elif self.spin_mode == "agent":
+            verb = self.spin_verb
+            detail = f"{elapsed}s" + (f" · ↓ {self.spin_tokens} tokens" if self.spin_tokens else "")
+            stop = "Esc pour interrompre"
+        else:
+            verb = "Réflexion" if self.spin_thinking and not self.spin_tokens else self.spin_verb
+            detail = f"{elapsed}s" + (f" · ↓ {self.spin_tokens} tokens" if self.spin_tokens else "")
+            stop = "Esc pour interrompre"
+        self.query_one("#spinner", Static).update(
+            Text.assemble((f"{frame} ", ORANGE), (f"{verb}…", f"bold {ORANGE}"), (f" ({detail} · {stop})", DIM))
+        )
+
+    def _spinner(self, active: bool, mode: str | None = None, verb: str = "") -> None:
+        if mode:
+            self.spin_mode = mode
+            self.spin_start = time.monotonic()
+            if mode == "model":
+                self.spin_tokens = 0
+                self.spin_thinking = False
+                self.spin_verb = random.choice(VERBS)
+            elif mode == "check":
+                self.spin_verb = verb or "Vérification"
+            elif mode == "agent":
+                self.spin_tokens = 0
+                self.spin_verb = verb or "Agent au travail"
+        spinner = self.query_one("#spinner", Static)
+        spinner.set_class(active, "-active")
+        if active:
+            self._tick_spinner()
+
+    # ------------------------------------------------------------------ affichage
+    @staticmethod
+    def user_widget(text: str) -> Static:
+        lines = text.splitlines() or [text]
+        shown = lines if len(lines) <= 12 else lines[:8]
+        body = Text()
+        for i, line in enumerate(shown):
+            body.append("> " if i == 0 else "  ", style=f"bold {DIM}")
+            body.append(line + ("\n" if i < len(shown) - 1 else ""), style=DIM)
+        if len(lines) > len(shown):
+            body.append(f"\n  … [+{len(lines) - len(shown)} lignes]", style=f"italic {DIM}")
+        return Static(body, classes="user")
+
+    def add_user(self, text: str) -> None:
+        self.chat.mount(self.user_widget(text))
+        self.call_after_refresh(self._follow)
+
+    def add_notice(self, text: str, style: str = DIM) -> None:
+        self.chat.mount(Static(Text.assemble(("⎿  ", DIM), (text, style)), classes="notice"))
+        self.call_after_refresh(self._follow)
+
+    def add_notice_md(self, markdown: str) -> None:
+        self.chat.mount(Markdown(markdown, classes="notice-md"))
+        self.call_after_refresh(self._follow)
+        self.set_timer(0.2, self._follow)   # un tableau Markdown s'affiche un peu après : suivre sa vraie hauteur
+
+    async def _new_bubble(self, text: str = "") -> AssistantMessage:
+        bubble = AssistantMessage(text)
+        await self.chat.mount(bubble)
+        self.call_after_refresh(self._follow)
+        return bubble
+
+    async def _new_tool_view(self, command: str, label: str = "PowerShell",
+                             waiting: str = "En attente de ta validation…") -> ToolCallView:
+        view = ToolCallView(command, label, waiting)
+        # Pendant le travail d'un agent, ses outils s'affichent en retrait dans son cadre
+        await (self._tool_parent or self.chat).mount(view)
+        self.call_after_refresh(self._follow)
+        return view
+
+    async def _new_search_view(self, requete: str) -> SearchView:
+        view = SearchView(requete)
+        await self.chat.mount(view)
+        self.call_after_refresh(self._follow)
+        return view
+
+    async def _new_agent_view(self, name: str, task: str) -> AgentView:
+        view = AgentView(name, task)
+        await self.chat.mount(view)
+        self.call_after_refresh(self._follow)
+        return view
+
+    def action_toggle_details(self) -> None:
+        """Ctrl+O : afficher ou replier le détail du travail des agents."""
+        views = [v for v in self.query(AgentView) if v.done]
+        if not views:
+            return
+        self.show_details = not self.show_details
+        for view in views:
+            view.set_expanded(self.show_details)

package/tui/promethee/app/envoi.py

@@ -0,0 +1,141 @@
+"""Envoi d'un message, mode « ! », message système et estimation du contexte."""
+from __future__ import annotations
+
+import datetime as dt
+import json
+import time
+
+from textual import work
+
+from ..agents import agent_tool_def, agents_guide, list_agents
+from ..completion import expand_attachments
+from ..consignes import TOOLS, TOOL_GUIDE
+from ..memoire import MEMORY_INTRO, read_memory
+from ..recherche import search_answer_rules
+from ..securite import is_dangerous
+from ..shell import shell_message
+from ..theme import DIM, YELLOW
+from ..widgets import ToolCallView
+
+
+class Envoi:
+    """Partie de PrometheeApp : envoi d'un message, mode « ! », message système et estimation du contexte."""
+
+    def send_message(self, text: str, content: str | None = None, intent: str | None = None,
+                     mode: str | None = None) -> None:
+        """Envoie un message (text = ce qui s'affiche ; content = ce que reçoit le modèle, si différent ;
+        intent = ce que lit l'interpréteur à la place du texte affiché ; mode = « action » imposé)."""
+        if self.generating:
+            self.notify("Prométhée travaille encore. Esc pour l'interrompre.", severity="warning")
+            return
+        if self.tasks and all(t["state"] == "done" for t in self.tasks):
+            self.tasks = []  # la tâche précédente est finie
+        self.add_user(text)
+        if not self.session_title:
+            self.session_title = " ".join(text.split())[:70]
+        expanded, notes = expand_attachments(content or text, self.cwd)
+        for shown, summary, ok in notes:
+            self.add_notice(f"Lu {shown} ({summary})" if ok else f"@{shown} : {summary}", DIM if ok else YELLOW)
+        message = {"role": "user", "content": expanded}
+        if expanded != text:
+            message["display"] = text  # affiché (et utilisé par l'interpréteur) à la place du contenu complet
+        if intent:
+            message["intent"] = intent  # commande personnalisée, /init : l'interpréteur lit la vraie demande
+        if mode:
+            message["mode"] = mode
+        self.messages.append(message)
+        self.generating = True
+        self.cancel_event.clear()
+        self._run_plan = self.plan_mode
+        self._spinner(True, "model")
+        self.render_tasks()
+        self.run_agent(list(self.messages), self.model, self.plan_mode)
+
+    @work(thread=True, exclusive=True, group="generate")
+    def run_shell(self, command: str, view: ToolCallView) -> None:
+        """« ! commande » : tapée par toi. Une lecture part tout de suite ; une commande sensible, risquée ou hors
+        politique te demande une confirmation ; un refus de la politique vaut aussi pour toi."""
+        verdict = self._verdict(command)
+        if verdict is not None and verdict.refusee:
+            self.call_from_thread(view.set_refused, verdict.resume(), verdict.conseils())
+            self.noter_refus(command, verdict, "toi")
+            self.call_from_thread(self.finish_shell, command, None, "", "", False)
+            return
+        if is_dangerous(command) or (verdict is not None and not verdict.lecture):
+            decision = self._wait_choice(lambda done: self.show_permission(command, "", done, verdict, direct=True))
+            if decision != "yes":
+                self.call_from_thread(view.set_denied)
+                self.noter_commande(command, None, "", "annulée par toi", time.monotonic(), self.cwd, verdict, "refus", "toi")
+                self.call_from_thread(self.finish_shell, command, None, "", "", False)
+                return
+        self.call_from_thread(view.set_running)
+        self.call_from_thread(self._spinner, True, "command")
+        started, where = time.monotonic(), self.cwd
+        code, output, note = self._execute(command, verdict)
+        self.noter_commande(command, code, output, note, started, where, verdict, "toi", "toi")
+        self.last_output = output
+        self.call_from_thread(view.set_result, code, output, note)
+        self.call_from_thread(self.finish_shell, command, code, output, note)
+
+    def finish_shell(self, command: str, code: int | None, output: str, note: str, ran: bool = True) -> None:
+        self.generating = False
+        self._spinner(False)
+        if self._perm is not None:
+            self.hide_permission()
+        if not ran:
+            return   # refusée par la politique ou annulée : rien n'a tourné, rien n'entre dans la conversation
+        self.messages.append({"role": "user", "content": shell_message(command, code, output, note)})
+        if not self.session_title:
+            self.session_title = f"! {command}"[:70]
+        self.ctx_used = max(self.ctx_used, self.estimate_tokens())
+        self.update_status()
+        self.save_session()
+        self.call_after_refresh(self._follow)
+        self._maybe_auto_compact()
+
+    def memory_text(self) -> str:
+        memory = read_memory(self.cwd)
+        if not memory:
+            return ""
+        return MEMORY_INTRO + "".join(f"\n\n### Mémoire {label}\n{text}" for label, _, text in memory)
+
+    def _system_extra(self) -> str:
+        """Mémoire et résumé de la conversation compactée, ajoutés aux consignes du modèle."""
+        extra = self.memory_text()
+        if self.summary:
+            extra += f"\n\n## Résumé de la conversation précédente (compactée)\n{self.summary}"
+        return extra
+
+    def search_system(self, search: dict) -> dict:
+        """Consignes de la réponse qui suit une recherche web, comme la console : celles du modèle sans le guide des
+        outils (aucune commande dans ce tour), puis les consignes de la recherche."""
+        base = (self.model_system or "") + self._system_extra()
+        rules = search_answer_rules(search)
+        return {"role": "system", "content": f"{base}\n\n{rules}" if base else rules}
+
+    def system_message(self) -> dict | None:
+        extra = self._system_extra()
+        if not self.supports_tools:
+            if not extra:
+                return None  # le SYSTEM du Modelfile s'applique
+            return {"role": "system", "content": (self.model_system or "") + extra}
+        guide = TOOL_GUIDE.format(cwd=self.cwd, date=dt.date.today().strftime("%d/%m/%Y"))
+        agents = list_agents(self.cwd)
+        if agents:
+            guide += agents_guide(agents)
+        return {"role": "system", "content": (self.model_system or "") + guide + extra}
+
+    def request_tools(self) -> list[dict]:
+        """Outils envoyés au modèle principal : commandes, fichiers, et lancer_agent s'il y a des agents."""
+        agents = list_agents(self.cwd)
+        return TOOLS + ([agent_tool_def(agents)] if agents else [])
+
+    def estimate_tokens(self) -> int:
+        """Estimation de la taille du contexte (≈ 3 caractères par jeton + définitions des outils)."""
+        system = self.system_message() or {}
+        chars = len(system.get("content", ""))
+        for m in self.messages:
+            chars += len(str(m.get("content") or ""))
+            if m.get("tool_calls"):
+                chars += len(json.dumps(m["tool_calls"], ensure_ascii=False))
+        return int(chars / 3.0) + (1250 if self.supports_tools else 0)