Assistant IA : se rabattre sur l'ecran visible si rien n'est selectionne

Signale par l'utilisateur : "Expliquer cette sortie" n'avait aucun effet
utilisable, le menu restait grise. Cause reelle : ces actions exigeaient une
selection prealable dans le terminal, alors que l'attente naturelle ("explique
ce que j'ai a l'ecran") est de pouvoir les utiliser directement sur ce qui est
affiche - confirme avec l'utilisateur avant d'implementer (deux options
proposees : rabattre sur l'ecran visible, ou juste clarifier le blocage).

app/terminal_widget.py : nouvelle methode visible_text() (l'ecran actuellement
affiche, sans l'historique de scroll - au contraire de buffer_text() qui sert
a la detection de commande ssh et remonte l'historique proche).

app/ui/tabs.py : Expliquer/Diagnostiquer/Proposer une solution/Poser une
question utilisent desormais _ai_source_text() = la selection si elle existe
(pour cibler precisement), sinon l'ecran visible. Les 3 premieres actions du
menu ne sont plus desactivees des qu'il n'y a pas de selection, mais
seulement si vraiment rien n'est affiche ; "Poser une question" reste
utilisable meme un terminal vide (contexte optionnel, comme le bouton
"Nouvelle question" du panneau).

tests/test_ai_tab_integration.py : reecriture des tests 1 et 2 (etats
d'activation du menu) + 2 nouveaux tests verifiant explicitement le repli
(sans selection, le texte envoye est bien celui de l'ecran) et sa priorite
inverse (une selection existante prime toujours sur l'ecran visible).
tests/test_clipboard.py : couverture directe de visible_text() (ecran complet,
lignes vides de fin retirees). Suite complete revalidee (34/34), ruff propre.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

app/terminal_widget.py

@@ -286,6 +286,16 @@ class TerminalWidget(QWidget):
         payload = text.replace("\r\n", "\r").replace("\n", "\r")
         self.data_to_send.emit(payload.encode("utf-8", errors="ignore"))
 
+    def visible_text(self) -> str:
+        """Ce qui est actuellement affiche a l'ecran (sans l'historique de
+        defilement) : repli de l'assistant IA quand rien n'est selectionne -
+        "expliquer cette sortie" doit alors porter sur ce que l'utilisateur a
+        reellement sous les yeux, pas sur tout le scrollback."""
+        lines = [line.rstrip() for line in self.screen.display]
+        while lines and not lines[-1]:
+            lines.pop()
+        return "\n".join(lines)
+
     def buffer_text(self) -> str:
         """Texte visible + historique proche, pour retrouver ce qui a ete tape
         (utilise pour deduire l'hote d'une commande ssh saisie a la main).

app/ui/tabs.py

@@ -301,30 +301,43 @@ class BaseTerminalTab(QWidget):
         menu = self._build_ai_menu()
         menu.exec(self.ai_btn.mapToGlobal(self.ai_btn.rect().bottomLeft()))
 
+    def _ai_source_text(self) -> str:
+        """Texte selectionne s'il y en a un (pour cibler precisement une
+        partie de la sortie), sinon tout l'ecran actuellement visible - pour
+        que "Expliquer cette sortie" porte par defaut sur ce que l'utilisateur
+        a reellement sous les yeux, sans obliger a selectionner au prealable."""
+        selection = self.terminal.selected_text()
+        return selection if selection else self.terminal.visible_text()
+
     def _build_ai_menu(self) -> QMenu:
         menu = QMenu(self)
-        has_selection = self.terminal.has_selection()
+        has_content = bool(self._ai_source_text().strip())
+        tooltip = (
+            "Utilise le texte selectionne, ou tout l'ecran visible si rien n'est selectionne."
+            if has_content else "Rien n'est encore affiche dans ce terminal."
+        )
 
         explain_action = menu.addAction("Expliquer cette sortie")
-        explain_action.setEnabled(has_selection)
+        explain_action.setEnabled(has_content)
+        explain_action.setToolTip(tooltip)
         explain_action.triggered.connect(self._ai_explain)
 
         diagnose_action = menu.addAction("Diagnostiquer cette erreur")
-        diagnose_action.setEnabled(has_selection)
+        diagnose_action.setEnabled(has_content)
+        diagnose_action.setToolTip(tooltip)
         diagnose_action.triggered.connect(self._ai_diagnose)
 
         solution_action = menu.addAction("Proposer une solution")
-        solution_action.setEnabled(has_selection)
+        solution_action.setEnabled(has_content)
+        solution_action.setToolTip(tooltip)
         solution_action.triggered.connect(self._ai_solution)
 
         ask_action = menu.addAction("Poser une question...")
-        ask_action.setEnabled(has_selection)
+        ask_action.setToolTip(
+            "La selection (ou l'ecran visible a defaut) est jointe comme contexte a la question."
+        )
         ask_action.triggered.connect(self._ai_ask)
 
-        if not has_selection:
-            for action in (explain_action, diagnose_action, solution_action, ask_action):
-                action.setToolTip("Selectionnez d'abord du texte dans le terminal.")
-
         menu.addSeparator()
         generate_action = menu.addAction("Generer une commande...")
         generate_action.triggered.connect(self._ai_generate_command)
@@ -367,18 +380,15 @@ class BaseTerminalTab(QWidget):
         self._run_ai_selection_action(KIND_SOLUTION, "Proposer une solution")
 
     def _run_ai_selection_action(self, kind: str, label: str) -> None:
-        selection = self.terminal.selected_text()
-        if not selection:
+        text = self._ai_source_text()
+        if not text.strip():
             return
         panel = self._ensure_ai_panel()
-        panel.run_request(kind, selection, label=label)
+        panel.run_request(kind, text, label=label)
 
     def _ai_ask(self) -> None:
-        selection = self.terminal.selected_text()
-        if not selection:
-            return
         panel = self._ensure_ai_panel()
-        panel.prompt_question(context=selection)
+        panel.prompt_question(context=self._ai_source_text())
 
     def _ai_generate_command(self) -> None:
         if self._ai_command_worker is not None and self._ai_command_worker.isRunning():