Initial commit

docs/archive/old-summaries/GUIDE_INTEGRATION_GUI.md

@@ -0,0 +1,369 @@
+# Guide d'Intégration de la GUI Améliorée
+
+## 🎯 Objectif
+
+Ce guide explique comment intégrer la nouvelle GUI améliorée dans votre application GeniusIA v2.
+
+## ✅ Composants Disponibles
+
+### Composants Principaux
+- **ImprovedGUI** : Interface principale avec LogsPanel et statistiques
+- **HumanLogger** : Générateur de messages lisibles
+- **GUISignals** : Système de signaux Qt pour communication
+- **InteractiveDialog** : Dialogues avec timeout
+- **OrchestratorGUIBridge** : Pont Orchestrator ↔ GUI
+
+### Modèles de Données
+- **GUIState** : État de la GUI
+- **LogMessage** : Messages de log
+
+## 🚀 Méthode 1 : Intégration Automatique (Recommandée)
+
+### Utilisation Simple
+
+```python
+from PyQt5.QtWidgets import QApplication
+from geniusia2.core import Orchestrator
+from geniusia2.gui import setup_gui_for_orchestrator
+
+# Créer l'application Qt
+app = QApplication(sys.argv)
+
+# Créer l'Orchestrator
+orchestrator = Orchestrator()
+
+# Configurer la GUI automatiquement
+bridge = setup_gui_for_orchestrator(orchestrator)
+bridge.show()
+
+# Maintenant l'orchestrator peut logger vers la GUI
+orchestrator.log_to_gui("👀", "Système démarré", "success")
+orchestrator.update_gui_stats(actions_count=0, patterns_count=0)
+
+# Lancer l'application
+sys.exit(app.exec_())
+```
+
+### Avantages
+- ✅ Configuration automatique
+- ✅ Connexion bidirectionnelle Orchestrator ↔ GUI
+- ✅ Méthodes helper ajoutées à l'Orchestrator
+- ✅ Gestion des signaux automatique
+
+## 🔧 Méthode 2 : Intégration Manuelle
+
+### Étape 1 : Créer la GUI
+
+```python
+from PyQt5.QtWidgets import QApplication
+from geniusia2.gui import ImprovedGUI
+
+app = QApplication(sys.argv)
+gui = ImprovedGUI(orchestrator)
+gui.show()
+```
+
+### Étape 2 : Connecter les Signaux
+
+```python
+from geniusia2.gui import add_gui_logging_to_orchestrator
+
+# Ajouter le logging GUI à l'orchestrator
+add_gui_logging_to_orchestrator(orchestrator, gui.signals)
+
+# Connecter les boutons de contrôle
+gui.start_requested.connect(orchestrator.start)
+gui.stop_requested.connect(orchestrator.stop)
+gui.pause_requested.connect(orchestrator.pause)
+```
+
+### Étape 3 : Utiliser dans l'Orchestrator
+
+```python
+class Orchestrator:
+    def on_action_observed(self, action):
+        # Logger vers la GUI
+        self.log_to_gui("👀", f"Action dans {action.window}", "info")
+        
+        # Mettre à jour les stats
+        self.update_gui_stats(
+            actions_count=self.actions_count,
+            patterns_count=self.patterns_count,
+            workflows_count=self.workflows_count
+        )
+    
+    def on_pattern_detected(self, pattern):
+        self.log_to_gui("🎯", "Pattern détecté !", "success")
+    
+    def on_mode_change(self, new_mode):
+        self.change_mode_gui(new_mode)
+        self.log_to_gui("✅", f"Mode {new_mode} activé", "success")
+```
+
+## 📝 Méthodes Disponibles dans l'Orchestrator
+
+Après l'intégration, ces méthodes sont disponibles :
+
+### log_to_gui(emoji, message, level)
+```python
+# Envoyer un log à la GUI
+orchestrator.log_to_gui("👀", "Message", "info")
+orchestrator.log_to_gui("✅", "Succès", "success")
+orchestrator.log_to_gui("⚠️", "Attention", "warning")
+orchestrator.log_to_gui("❌", "Erreur", "error")
+```
+
+### update_gui_stats(**stats)
+```python
+# Mettre à jour les statistiques
+orchestrator.update_gui_stats(
+    actions_count=12,
+    patterns_count=2,
+    workflows_count=1,
+    finetuning_status='collecting',
+    finetuning_progress=8
+)
+```
+
+### change_mode_gui(mode)
+```python
+# Changer le mode affiché
+orchestrator.change_mode_gui("shadow")   # 👀 Observation
+orchestrator.change_mode_gui("assist")   # 💡 Suggestions
+orchestrator.change_mode_gui("copilot")  # 🤝 Copilote
+orchestrator.change_mode_gui("auto")     # 🤖 Autonome
+```
+
+## 💬 Utiliser les Dialogues Interactifs
+
+### Dialogue Simple
+
+```python
+from geniusia2.gui import InteractiveDialog
+
+def on_accept():
+    print("Utilisateur a accepté")
+    orchestrator.change_mode("assist")
+
+def on_reject():
+    print("Utilisateur a refusé")
+
+# Afficher un dialogue
+dialog = InteractiveDialog.show_dialog(
+    "J'ai une idée !",
+    "Voulez-vous que je vous suggère des actions ?",
+    on_accept,
+    on_reject,
+    timeout_seconds=10
+)
+```
+
+### Dialogue via Signaux
+
+```python
+# Utiliser le signal show_dialog
+orchestrator.gui_signals.emit_dialog(
+    "Confirmation",
+    "Voulez-vous continuer ?",
+    on_accept,
+    on_reject
+)
+```
+
+## 📊 Exemples d'Utilisation
+
+### Exemple 1 : Observer une Action
+
+```python
+def on_action_observed(self, action):
+    # Incrémenter le compteur
+    self.actions_count += 1
+    
+    # Logger
+    message = self.human_logger.log_observation(
+        action.type,
+        action.window
+    )
+    self.log_to_gui("👀", message, "info")
+    
+    # Mettre à jour les stats
+    self.update_gui_stats(actions_count=self.actions_count)
+```
+
+### Exemple 2 : Détecter un Pattern
+
+```python
+def on_pattern_detected(self, pattern):
+    # Incrémenter le compteur
+    self.patterns_count += 1
+    
+    # Logger
+    message = self.human_logger.log_pattern_detected(
+        pattern.repetitions,
+        pattern.task_name
+    )
+    self.log_to_gui("🎯", message, "success")
+    
+    # Mettre à jour les stats
+    self.update_gui_stats(
+        actions_count=self.actions_count,
+        patterns_count=self.patterns_count
+    )
+    
+    # Demander confirmation pour changer de mode
+    def switch_to_assist():
+        self.change_mode("assist")
+        self.change_mode_gui("assist")
+        self.log_to_gui("✅", "Mode Suggestions activé", "success")
+    
+    InteractiveDialog.show_dialog(
+        "Pattern détecté !",
+        f"J'ai remarqué que vous faites souvent:\n\"{pattern.task_name}\"\n\n"
+        "Voulez-vous que je vous suggère cette action ?",
+        switch_to_assist,
+        lambda: None,
+        timeout_seconds=10
+    )
+```
+
+### Exemple 3 : Fine-tuning
+
+```python
+def on_finetuning_start(self, num_examples):
+    message = self.human_logger.log_finetuning_started(num_examples)
+    self.log_to_gui("🧠", message, "info")
+    
+    self.update_gui_stats(
+        finetuning_status='training',
+        finetuning_progress=None
+    )
+
+def on_finetuning_complete(self, duration):
+    message = self.human_logger.log_finetuning_completed(duration)
+    self.log_to_gui("✅", message, "success")
+    
+    self.update_gui_stats(
+        finetuning_status='completed',
+        finetuning_progress=None
+    )
+```
+
+### Exemple 4 : Gestion d'Erreurs
+
+```python
+def on_error(self, error_type, context=None):
+    message = self.human_logger.log_error(error_type, context)
+    self.log_to_gui("❌", message, "error")
+```
+
+## 🔄 Modifier main.py
+
+### Avant (MinimalGUI)
+
+```python
+from geniusia2.gui import MinimalGUI
+
+gui = MinimalGUI(orchestrator)
+gui.show()
+```
+
+### Après (ImprovedGUI)
+
+```python
+from geniusia2.gui import setup_gui_for_orchestrator
+
+bridge = setup_gui_for_orchestrator(orchestrator)
+bridge.show()
+```
+
+## 🧪 Tester l'Intégration
+
+### Test Simple
+
+```python
+# test_integration_gui.py
+from PyQt5.QtWidgets import QApplication
+from PyQt5.QtCore import QTimer
+import sys
+
+from geniusia2.core import Orchestrator
+from geniusia2.gui import setup_gui_for_orchestrator
+
+app = QApplication(sys.argv)
+
+# Créer et configurer
+orchestrator = Orchestrator()
+bridge = setup_gui_for_orchestrator(orchestrator)
+bridge.show()
+
+# Tester après 1 seconde
+def test():
+    orchestrator.log_to_gui("👀", "Test de log", "info")
+    orchestrator.update_gui_stats(actions_count=5)
+    orchestrator.change_mode_gui("assist")
+
+QTimer.singleShot(1000, test)
+
+sys.exit(app.exec_())
+```
+
+## 📋 Checklist d'Intégration
+
+- [ ] Importer `setup_gui_for_orchestrator`
+- [ ] Créer l'application Qt
+- [ ] Configurer le bridge
+- [ ] Afficher la GUI
+- [ ] Tester `log_to_gui()`
+- [ ] Tester `update_gui_stats()`
+- [ ] Tester `change_mode_gui()`
+- [ ] Tester les boutons de contrôle
+- [ ] Tester le system tray
+- [ ] Tester les dialogues interactifs
+
+## 🐛 Dépannage
+
+### La GUI ne s'affiche pas
+```python
+# Vérifier que l'application Qt est créée
+app = QApplication(sys.argv)
+# ... créer la GUI ...
+sys.exit(app.exec_())  # Important !
+```
+
+### Les logs n'apparaissent pas
+```python
+# Vérifier que le bridge est configuré
+bridge = setup_gui_for_orchestrator(orchestrator)
+
+# Vérifier que la méthode existe
+if hasattr(orchestrator, 'log_to_gui'):
+    orchestrator.log_to_gui("✅", "Test", "info")
+```
+
+### Les statistiques ne se mettent pas à jour
+```python
+# Utiliser un dictionnaire complet
+orchestrator.update_gui_stats(
+    actions_count=0,
+    patterns_count=0,
+    workflows_count=0
+)
+```
+
+## 📚 Ressources
+
+- **test_improved_gui.py** : Exemple complet avec simulation
+- **GUI_AMELIOREE_PRETE.md** : Guide détaillé de la GUI
+- **RESUME_GUI_COMPLETE.md** : Résumé des fonctionnalités
+
+## ✨ Conseils
+
+1. **Utilisez HumanLogger** pour générer des messages lisibles
+2. **Mettez à jour les stats régulièrement** pour une GUI réactive
+3. **Utilisez les dialogues** pour les confirmations importantes
+4. **Testez le system tray** sur Ubuntu
+5. **Gérez les erreurs** avec des messages clairs
+
+---
+
+**Bonne intégration ! 🚀**