@nosserb/prmt 0.0.0-stage → 2.0.0

package/tui/promethee/app/application.py

@@ -0,0 +1,299 @@
+"""L'application : état, mise en page, envoi des messages. Ses autres méthodes sont dans les modules voisins."""
+from __future__ import annotations
+
+import argparse
+import datetime as dt
+import os
+import subprocess
+import threading
+from pathlib import Path
+
+from textual import on
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical, VerticalScroll
+from textual.widget import Widget
+from textual.widgets import Static, TextArea
+
+from .clavier import Clavier
+from .commandes_slash import CommandesSlash
+from .contexte import Contexte
+from .definitions import Definitions
+from .ecran import Ecran
+from .envoi import Envoi
+from .historique import Historique
+from .modele import Modele
+from .notes import Notes
+from .outils import Outils
+from .plateforme import Plateforme
+from .saisie import Saisie
+from .taches import Taches
+from .tour import Tour
+from .validation import Validation
+from .. import preferences
+from ..accueil import Accueil
+from ..config import DEFAULT_MODEL
+from ..consignes import CODE_MODEL
+from ..conversation import list_sessions, new_session_id
+from ..logo import Logo
+from ..politique import Politique
+from ..textes import CSS, VERBS
+from ..theme import FONDS, THEMES, YELLOW
+from ..widgets import ChoicePrompt, PromptInput
+
+
+class PrometheeApp(Ecran, Saisie, Taches, Notes, Definitions, Contexte, Envoi, Tour, Outils, Validation, Historique, Modele,
+                   Plateforme, CommandesSlash, Clavier, App):
+    TITLE = "Prométhée"
+    CSS = CSS
+    BINDINGS = [
+        Binding("ctrl+c", "ctrl_c", show=False, priority=True),
+        Binding("escape", "escape", show=False, priority=True),
+        Binding("ctrl+d", "ctrl_d", show=False, priority=True),
+        Binding("ctrl+q", "quit", show=False, priority=True),
+        Binding("pageup", "scroll_chat(-1)", show=False, priority=True),
+        Binding("pagedown", "scroll_chat(1)", show=False, priority=True),
+        Binding("shift+tab", "toggle_plan", show=False, priority=True),
+        Binding("tab", "complete", show=False, priority=True),
+        Binding("ctrl+o", "toggle_details", show=False, priority=True),
+    ]
+
+    def __init__(self, model: str, start: str = "", politique: Politique | None = None) -> None:
+        super().__init__()
+        self.prefs = preferences.lire()
+        for theme in THEMES:
+            self.register_theme(theme)
+        self.theme = FONDS[self.prefs["fond"]]
+        self.model = model
+        self.summary = ""             # résumé de la conversation après /compact (ajouté au prompt système)
+        self.allow_edits = False      # « Oui pour toutes les modifications de fichiers » (session)
+        self.session_id = new_session_id()
+        self.session_created = dt.datetime.now().isoformat(timespec="seconds")
+        self.session_title = ""
+        self._start = start           # "continue" (prmt -c) ou "resume" (prmt -r)
+        self.plan_mode = False        # Shift+Tab : propose un plan sans rien exécuter
+        self._run_plan = False        # la réponse en cours a-t-elle été demandée en mode plan ?
+        self.tasks: list[dict] = []   # liste de tâches affichée (plan accepté ou audit)
+        self.task_kind = ""
+        self._comp_items: list[tuple[str, str, str]] = []  # menu d'autocomplétion ( / ou @ )
+        self._comp_kind = ""
+        self._comp_index = 0
+        self._comp_dismissed: str | None = None
+        self._tool_parent: Widget | None = None  # pendant un agent : ses outils s'affichent dans son cadre
+        self._agent_name = ""                     # agent en cours (son nom s'affiche dans les validations)
+        self.show_details = False                 # Ctrl+O : détail du travail des agents
+        self._agent_draft: str | None = None      # /agents → créer : « global » ou « dossier », en attente de la description
+        self._draft_kind = "agent"                # … d'un agent ou d'une commande personnalisée
+        self._esc_at = 0.0                        # Esc Esc : revenir en arrière
+        self._memory_rejected: set[str] = set()   # fichiers inexistants déjà signalés dans un PROMETHEE.md
+        self.code_model = CODE_MODEL              # IA de code (/code pour la changer ou couper la bascule)
+        self.code_auto = True
+        self._is_code = False                     # dernière demande classée « programmation » par l'interpréteur
+        self._last_code = False                   # la réponse précédente venait de l'IA de code
+        self._turn_model: str | None = None       # modèle qui répond en ce moment
+        self._loaded_model: str | None = None     # dernier modèle utilisé (déjà en mémoire GPU)
+        self._caps: dict[str, list[str] | None] = {}
+        self._code_warned = False
+        self.model_desc = ""                      # taille et quantification, affichées à l'accueil et dans /etat
+        self.model_system = ""
+        self.supports_tools = False
+        self.supports_thinking = False
+        self.messages: list[dict] = []
+        self._generating = False
+        self._clear_after = False                 # /clear demandé pendant un travail : effacer dès qu'il se termine
+        self.cancel_event = threading.Event()
+        self._resp = None
+        self._proc: subprocess.Popen | None = None
+        self._perm: ChoicePrompt | None = None
+        self.cwd = Path.cwd()
+        # Politique d'exécution : liste blanche et périmètre partagés avec la console (voir politique.py)
+        self.politique = politique if politique is not None else Politique(self.prefs["politique"])
+        self._policy_warned = False               # la panne du moteur de politique a déjà été signalée
+        self._policy_stop = False                 # la réponse en cours s'arrête après deux refus de la politique
+        self.ps_version = ""                      # version de PowerShell, mesurée au premier /etat
+        self.allowed: set[str] = set()            # lectures reconnues autorisées pour la session, par nom
+        self.allowed_lines: set[str] = set()      # autres commandes autorisées pour la session, ligne exacte
+        self.last_output = ""
+        self.num_ctx: int | None = None
+        self.ctx_used = 0
+        self.last_tps: float | None = None
+        self.last_answer = ""
+        self.model_state = "chargement…"
+        self.spin_start = 0.0
+        self.spin_tokens = 0
+        self.spin_verb = VERBS[0]
+        self.spin_thinking = False
+        self.spin_mode = "model"  # "model" ou "command"
+        self._ctrl_c_at = 0.0
+
+    @property
+    def generating(self) -> bool:
+        """Un travail est en cours (réponse du modèle, commande « ! », compactage, création d'un agent)."""
+        return self._generating
+
+    @generating.setter
+    def generating(self, value: bool) -> None:
+        self._generating = value
+        if not value and self._clear_after:
+            # Le travail interrompu par /clear vient de se terminer : on efface maintenant, après lui
+            self._clear_after = False
+            self.call_later(self.clear_conversation)
+
+    # ------------------------------------------------------------------ layout
+    def compose(self) -> ComposeResult:
+        chat = VerticalScroll(id="chat")
+        chat.can_focus = False
+        with chat:
+            yield from self._welcome_widgets()
+        with Vertical(id="bottom"):
+            yield Static(id="tasks")
+            yield Static(id="spinner")
+            with Horizontal(id="input-box"):
+                yield Static(">", id="prompt-char")
+                yield PromptInput(id="input", placeholder="Pose ta question à Prométhée…  (/aide pour l'aide)")
+            yield Static(id="completions")
+            with Horizontal(id="status-line"):
+                yield Static(id="hints")
+                yield Static(id="status")
+
+    def _welcome_widgets(self):
+        yield Logo()
+        yield Accueil()
+
+    def on_mount(self) -> None:
+        self.input.focus()
+        self.watch(self.screen, "focused", self._keep_focus)
+        self.set_interval(0.1, self._tick_spinner)
+        self.set_hints()
+        self.update_status()
+        self.load_model()
+        self.demarrer_politique()
+        if self._start == "continue":
+            sessions = list_sessions(1)
+            if sessions:
+                self.call_after_refresh(self.load_session, sessions[0])
+            else:
+                self.add_notice("Aucune conversation enregistrée à reprendre.", YELLOW)
+        elif self._start == "resume":
+            self.call_after_refresh(self.cmd_resume, "")
+
+    def on_unmount(self) -> None:
+        self.cancel_event.set()
+        prompt, self._perm = self._perm, None
+        if prompt is not None:
+            prompt.resolve("no")
+        self._kill_proc()
+        self.politique.fermer()
+
+    def _keep_focus(self, focused) -> None:
+        # La saisie (ou la demande de validation) garde toujours le focus.
+        target = self._perm if self._perm is not None else self.input
+        if focused is not target:
+            self.call_after_refresh(target.focus)
+
+    def on_resize(self, event) -> None:
+        for logo in self.query(Logo):
+            logo.refresh(layout=True)
+        self.update_status()   # la jauge de contexte ne s'affiche que si la largeur le permet
+
+    def _follow(self) -> None:
+        """Suit le bas de la conversation, seulement quand elle dépasse la hauteur de l'écran.
+
+        (Ancrer un contenu plus court que l'écran le collerait en bas : l'accueil doit rester en haut.)
+        """
+        chat = self.chat
+        if not chat.is_anchored and chat.max_scroll_y > 0:
+            chat.anchor()
+
+    @property
+    def chat(self) -> VerticalScroll:
+        return self.query_one("#chat", VerticalScroll)
+
+    @property
+    def input(self) -> PromptInput:
+        return self.query_one("#input", PromptInput)
+
+    @on(TextArea.Changed, "#input")
+    def _input_changed(self, event: TextArea.Changed) -> None:
+        # Modes « ! » (commande) et « # » (mémoire) : la barre de saisie change de couleur, comme dans Claude Code
+        text = self.input.text
+        shell, memory = text.startswith("!"), text.startswith("#")
+        box = self.query_one("#input-box")
+        if shell != box.has_class("-shell") or memory != box.has_class("-memory"):
+            box.set_class(shell, "-shell")
+            box.set_class(memory, "-memory")
+            self.query_one("#prompt-char", Static).update("!" if shell else "#" if memory else ">")
+        self.update_completions()
+
+    @on(TextArea.SelectionChanged, "#input")
+    def _input_cursor_moved(self, event: TextArea.SelectionChanged) -> None:
+        self.update_completions()
+
+    # ------------------------------------------------------------------ envoi
+    @on(PromptInput.Submitted)
+    async def on_submit(self, event: PromptInput.Submitted) -> None:
+        text = event.value.strip("\n").rstrip()
+        stripped = text.strip()
+        if stripped.startswith("/") and "\n" not in stripped:
+            self.input.remember(stripped)
+            self.input.clear()
+            if self._agent_draft is not None:
+                self.set_agent_draft(None)
+            await self.run_command(stripped)
+            return
+        if self.generating:
+            self.notify("Prométhée travaille encore. Esc pour l'interrompre.", severity="warning")
+            return
+        if self._agent_draft is not None:
+            if not stripped:
+                return
+            scope, kind = self._agent_draft, self._draft_kind
+            self.set_agent_draft(None)
+            self.input.remember(stripped)
+            self.input.clear()
+            self.add_user(stripped)
+            self.generating = True
+            self.cancel_event.clear()
+            if kind == "commande":
+                self._spinner(True, "check", "Prométhée écrit la commande")
+                self.generate_command(stripped, scope)
+            else:
+                self._spinner(True, "check", "Prométhée écrit l'agent")
+                self.generate_agent(stripped, scope)
+            return
+        if stripped.startswith("!"):
+            command = stripped[1:].strip()
+            if not command:
+                self.notify("Tape une commande après le « ! », par exemple : ! ipconfig", severity="warning")
+                return
+            self.input.remember(stripped)
+            self.input.clear()
+            view = await self._new_tool_view(command, "!", "Contrôle de la commande…")
+            self.generating = True
+            self.cancel_event.clear()
+            self._spinner(True, "check", "Contrôle de la commande")
+            self.run_shell(command, view)
+            return
+        if stripped.startswith("#"):
+            note = " ".join(stripped[1:].split())
+            if not note:
+                self.notify("Écris l'information après le « # », par exemple : # ma box est en 192.168.1.1",
+                            severity="warning")
+                return
+            self.input.remember(stripped)
+            self.input.clear()
+            self.ask_memory_target(note)
+            return
+        self.input.remember(text)
+        self.input.clear()
+        self.send_message(text)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="prmt", description="Prométhée : IA locale de cybersécurité")
+    parser.add_argument("-m", "--model", default=os.environ.get("PRMT_MODEL", DEFAULT_MODEL), help="modèle Ollama à utiliser")
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument("-c", "--continue", dest="cont", action="store_true", help="reprendre la dernière conversation")
+    group.add_argument("-r", "--resume", action="store_true", help="choisir une conversation à reprendre")
+    args = parser.parse_args()
+    PrometheeApp(args.model, "continue" if args.cont else "resume" if args.resume else "").run()

package/tui/promethee/app/clavier.py

@@ -0,0 +1,99 @@
+"""Actions du clavier : Esc, Ctrl+C, Ctrl+D, défilement."""
+from __future__ import annotations
+
+import threading
+import time
+
+from ..theme import DIM
+
+
+class Clavier:
+    """Partie de PrometheeApp : actions du clavier : Esc, Ctrl+C, Ctrl+D, défilement."""
+
+    # ------------------------------------------------------------------ actions clavier
+    def action_escape(self) -> None:
+        if self._perm is not None:
+            self._perm.resolve("no")
+            return
+        if self._comp_items:
+            self.hide_completions()
+            return
+        if self._agent_draft is not None and not self.generating:
+            what = "de l'agent" if self._draft_kind == "agent" else "de la commande"
+            self.set_agent_draft(None)
+            self.input.clear()
+            self.add_notice(f"Création {what} annulée.", DIM)
+            return
+        if self.generating:
+            self.interrompre()
+        elif self.input.text:
+            self.input.clear()
+        else:
+            # Esc deux fois de suite (saisie vide) : revenir à un message précédent, comme dans Claude Code
+            now = time.monotonic()
+            if now - self._esc_at < 0.8:
+                self._esc_at = 0.0
+                self.open_rewind()
+            else:
+                self._esc_at = now
+
+    def interrompre(self) -> None:
+        """Arrête le travail en cours : validation en attente, réponse du modèle, commande lancée."""
+        if self._perm is not None:
+            self._perm.resolve("no")
+        self.cancel_event.set()
+        resp = self._resp
+        if resp is not None:
+            threading.Thread(target=self._close_quietly, args=(resp,), daemon=True).start()
+        self._kill_proc()
+
+    @staticmethod
+    def _close_quietly(resp) -> None:
+        try:
+            resp.close()
+        except Exception:
+            pass
+
+    def action_ctrl_c(self) -> None:
+        selected = None
+        try:
+            selected = self.screen.get_selected_text()
+        except Exception:
+            pass
+        if not selected and self._perm is None and self.input.selected_text:
+            selected = self.input.selected_text
+        if selected:
+            self.copy_text(selected)
+            try:
+                self.screen.clear_selection()
+            except Exception:
+                pass
+            self.notify("Sélection copiée", timeout=2)
+            return
+        if self._perm is not None or self.generating:
+            self.action_escape()
+            return
+        if self.input.text:
+            self.input.clear()
+            return
+        now = time.monotonic()
+        if now - self._ctrl_c_at < 2:
+            self.exit()
+            return
+        self._ctrl_c_at = now
+        self.set_hints("Appuie encore sur Ctrl+C pour quitter", warn=True)
+        self.set_timer(2, self.set_hints)
+
+    def action_ctrl_d(self) -> None:
+        if self._perm is not None:
+            return
+        if self.input.text:
+            self.input.action_delete_right()
+        else:
+            self.exit()
+
+    def action_scroll_chat(self, direction: int) -> None:
+        if direction < 0:
+            self.chat.scroll_page_up()
+        else:
+            self.chat.scroll_page_down()

package/tui/promethee/app/commandes_slash.py

@@ -0,0 +1,164 @@
+"""Aiguillage des commandes « / » et commandes simples (aide, modèle, copier, sauver, effacer)."""
+from __future__ import annotations
+
+import datetime as dt
+import inspect
+import re
+
+from ..agents import AGENT_TOOL
+from ..appels import call_args
+from ..commandes import expand_command, find_command, find_custom_command
+from ..config import SAVE_DIR
+from ..consignes import FILE_TOOL_NAMES, SEARCH_TOOL_NAMES
+from ..conversation import new_session_id
+from ..fichiers import search_desc
+from ..presse_papiers import copy_windows
+from ..recherche import OUTIL as WEB_TOOL
+from ..textes import HELP
+from ..theme import GREEN, PLAN_COLOR, RED, YELLOW
+
+
+class CommandesSlash:
+    """Partie de PrometheeApp : aiguillage des commandes « / » et commandes simples (aide, modèle, copier, sauver, effacer)."""
+
+    # ------------------------------------------------------------------ commandes
+    async def run_command(self, cmd: str) -> None:
+        """Lance une commande « / ». La liste, ses alias et la méthode qui traite chacune sont dans commandes.COMMANDS."""
+        name, _, arg = cmd[1:].partition(" ")
+        name, arg = name.lower(), arg.strip()
+        command = find_command(name)
+        if command is None:
+            custom = find_custom_command(name, self.cwd)
+            if custom is not None:
+                # Commande personnalisée : son texte part à Prométhée comme un message
+                if self.generating:
+                    self.notify("Prométhée travaille encore. Esc pour l'interrompre.", severity="warning")
+                    return
+                content = expand_command(custom, arg)
+                self.send_message(cmd, content, intent=content)
+                return
+            self.add_user(cmd)
+            self.add_notice(f"Commande inconnue : /{name}. Tape /aide pour la liste.", YELLOW)
+            return
+        if command.nom != "/clear":
+            self.add_user(cmd)   # /clear efface l'écran : inutile d'y afficher la commande
+        result = getattr(self, command.action)(arg)
+        if inspect.isawaitable(result):
+            await result
+
+    def cmd_aide(self, arg: str = "") -> None:
+        self.add_notice_md(HELP)
+
+    def cmd_modele(self, arg: str = "") -> None:
+        if self.generating and arg:
+            self.add_notice("Attends la fin de la réponse avant de changer de modèle.", YELLOW)
+        else:
+            self.list_models(arg or None)
+
+    def cmd_sortie(self, arg: str = "") -> None:
+        if self.last_output:
+            self.add_notice_md(f"**Sortie complète de la dernière commande**\n\n```text\n{self.last_output}\n```")
+        else:
+            self.add_notice("Aucune commande exécutée pour l'instant.", YELLOW)
+
+    def cmd_compact(self, arg: str = "") -> None:
+        self.start_compact(arg)
+
+    def cmd_memoire(self, arg: str = "") -> None:
+        if arg.lower() in ("ouvrir", "open", "modifier", "edit", "editer", "éditer"):
+            self.open_memory()
+        else:
+            self.show_memory()
+
+    def cmd_plan(self, arg: str = "") -> None:
+        self.set_plan_mode(not self.plan_mode)
+        self.add_notice("Mode plan activé : Prométhée propose un plan sans rien exécuter (Shift+Tab ou /plan "
+                        "pour quitter)." if self.plan_mode else "Mode plan désactivé.", PLAN_COLOR)
+
+    def cmd_quitter(self, arg: str = "") -> None:
+        self.exit()
+
+    async def clear_conversation(self, arg: str = "") -> None:
+        if self.generating:
+            # Le travail en cours est interrompu ; l'effacement se fait quand il a rendu la main (voir le
+            # setter de « generating »). Avant, sa fin remettait l'ancienne conversation en place après l'effacement.
+            self._clear_after = True
+            self.interrompre()
+            return
+        self.messages = []
+        self.summary = ""
+        # Une nouvelle conversation repart sans autorisation de session
+        self.allow_edits = False
+        self.allowed.clear()
+        self.allowed_lines.clear()
+        self.session_id = new_session_id()
+        self.session_created = dt.datetime.now().isoformat(timespec="seconds")
+        self.session_title = ""
+        self.last_answer = ""
+        self.ctx_used = 0
+        self.tasks = []
+        self.render_tasks()
+        if self._agent_draft is not None:
+            self.set_agent_draft(None)
+        await self.chat.remove_children()
+        await self.chat.mount_all(list(self._welcome_widgets()))
+        self.chat.anchor(False)
+        self.chat.scroll_home(animate=False)
+        self.update_status()
+        self.notify("Nouvelle conversation", timeout=2)
+
+    def copy_text(self, text: str) -> None:
+        if not copy_windows(text):
+            self.copy_to_clipboard(text)  # repli : séquence OSC 52 du terminal
+
+    def cmd_copy(self, arg: str = "") -> None:
+        if not self.last_answer:
+            self.add_notice("Rien à copier pour l'instant.", YELLOW)
+            return
+        text = self.last_answer
+        if arg.lower().startswith("code"):
+            blocks = re.findall(r"```[^\n]*\n(.*?)```", text, flags=re.S)
+            if not blocks:
+                self.add_notice("Pas de bloc de code dans la dernière réponse.", YELLOW)
+                return
+            text = "\n\n".join(b.rstrip("\n") for b in blocks)
+        self.copy_text(text)
+        what = "Blocs de code copiés" if arg.lower().startswith("code") else "Dernière réponse copiée"
+        self.add_notice(f"{what} dans le presse-papiers ({len(text)} caractères).", GREEN)
+
+    def cmd_save(self, arg: str = "") -> None:
+        if not self.messages:
+            self.add_notice("La conversation est vide.", YELLOW)
+            return
+        now = dt.datetime.now()
+        path = SAVE_DIR / f"conversation-{now:%Y-%m-%d_%H-%M-%S}.md"
+        out = [f"# Conversation Prométhée ({self.model}), {now:%d/%m/%Y %H:%M}\n"]
+        for m in self.messages:
+            if m["role"] == "user":
+                out.append(f"## Toi\n\n{m['content']}\n")
+            elif m["role"] == "assistant":
+                if m.get("content", "").strip():
+                    out.append(f"## Prométhée\n\n{m['content']}\n")
+                for call in m.get("tool_calls") or []:
+                    name = (call.get("function") or {}).get("name") or "?"
+                    args = call_args(call)
+                    if name in FILE_TOOL_NAMES:
+                        out.append(f"**{name}** : `{args.get('chemin', '')}`\n")
+                    elif name in SEARCH_TOOL_NAMES:
+                        out.append(f"**{name}** : {search_desc(name, args, str(args.get('dossier') or ''))}\n")
+                    elif name == AGENT_TOOL:
+                        out.append(f"**Agent {args.get('agent', '?')}** : {args.get('tache', '')}\n")
+                    elif name == WEB_TOOL:
+                        out.append(f"**Recherche web** : « {args.get('requete', '')} »\n")
+                    else:
+                        command = args.get("commande") or args.get("command") or args.get("cmd") or ""
+                        out.append(f"**Commande exécutée :**\n\n```powershell\n{command}\n```\n")
+            elif m["role"] == "tool":
+                out.append(f"**Résultat :**\n\n```text\n{m['content']}\n```\n")
+        try:
+            SAVE_DIR.mkdir(parents=True, exist_ok=True)
+            path.write_text("\n".join(out), encoding="utf-8")
+        except OSError as err:
+            self.add_notice(f"Enregistrement impossible dans {path} : {err}", f"bold {RED}")
+            return
+        self.add_notice(f"Conversation enregistrée : {path}", GREEN)