Initial commit

docs/archive/old-summaries/AJOUTER_LOGS_ORCHESTRATOR.md

@@ -0,0 +1,255 @@
+# 📝 Ajouter des Logs dans l'Orchestrator
+
+## 🎯 Problème
+
+La GUI est connectée mais ne reçoit pas d'informations car l'Orchestrator n'envoie pas encore de logs.
+
+## ✅ Solution
+
+Ajouter des appels `log_to_gui()` et `update_gui_stats()` dans l'Orchestrator.
+
+## 📍 Où Ajouter les Logs
+
+### 1. Dans `orchestrator.py` - Méthode `run()`
+
+Quand l'observation démarre :
+
+```python
+def run(self):
+    """Boucle cognitive principale."""
+    self.running = True
+    
+    # LOG: Démarrage
+    if hasattr(self, 'log_to_gui'):
+        self.log_to_gui("👀", "Observation démarrée", "success")
+    
+    while self.running:
+        # ... votre code ...
+```
+
+### 2. Quand une Action est Observée
+
+```python
+def on_action_observed(self, action):
+    """Appelé quand une action est observée."""
+    # Votre code existant...
+    
+    # LOG: Action observée
+    if hasattr(self, 'log_to_gui'):
+        self.log_to_gui("👀", f"Action dans {action.window}", "info")
+        self.update_gui_stats(actions_count=self.actions_count)
+```
+
+### 3. Quand un Pattern est Détecté
+
+```python
+def on_pattern_detected(self, pattern):
+    """Appelé quand un pattern est détecté."""
+    # Votre code existant...
+    
+    # LOG: Pattern détecté
+    if hasattr(self, 'log_to_gui'):
+        message = self.human_logger.log_pattern_detected(
+            pattern.repetitions,
+            pattern.task_name
+        )
+        self.log_to_gui("🎯", message, "success")
+        self.update_gui_stats(
+            actions_count=self.actions_count,
+            patterns_count=self.patterns_count
+        )
+```
+
+### 4. Quand un Workflow est Appris
+
+```python
+def on_workflow_learned(self, workflow):
+    """Appelé quand un workflow est appris."""
+    # Votre code existant...
+    
+    # LOG: Workflow appris
+    if hasattr(self, 'log_to_gui'):
+        message = self.human_logger.log_workflow_learned(
+            workflow.name,
+            workflow.observation_count
+        )
+        self.log_to_gui("📚", message, "info")
+        self.update_gui_stats(
+            actions_count=self.actions_count,
+            patterns_count=self.patterns_count,
+            workflows_count=self.workflows_count
+        )
+```
+
+### 5. Quand le Mode Change
+
+```python
+def change_mode(self, new_mode):
+    """Change le mode opérationnel."""
+    old_mode = self.mode
+    self.mode = new_mode
+    
+    # LOG: Changement de mode
+    if hasattr(self, 'log_to_gui'):
+        message = self.human_logger.log_mode_change(old_mode, new_mode)
+        self.change_mode_gui(new_mode)
+        self.log_to_gui("✅", message, "success")
+```
+
+### 6. Quand une Erreur Survient
+
+```python
+def on_error(self, error_type, context=None):
+    """Appelé quand une erreur survient."""
+    # Votre code existant...
+    
+    # LOG: Erreur
+    if hasattr(self, 'log_to_gui'):
+        message = self.human_logger.log_error(error_type, context)
+        self.log_to_gui("❌", message, "error")
+```
+
+### 7. Fine-tuning
+
+```python
+def on_finetuning_start(self, num_examples):
+    """Appelé au début du fine-tuning."""
+    if hasattr(self, 'log_to_gui'):
+        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):
+    """Appelé à la fin du fine-tuning."""
+    if hasattr(self, 'log_to_gui'):
+        message = self.human_logger.log_finetuning_completed(duration)
+        self.log_to_gui("✅", message, "success")
+        self.update_gui_stats(
+            finetuning_status='completed',
+            finetuning_progress=None
+        )
+```
+
+## 🔍 Vérifier que les Méthodes Existent
+
+Toujours vérifier avec `hasattr()` avant d'appeler :
+
+```python
+if hasattr(self, 'log_to_gui'):
+    self.log_to_gui("👀", "Message", "info")
+
+if hasattr(self, 'update_gui_stats'):
+    self.update_gui_stats(actions_count=12)
+
+if hasattr(self, 'change_mode_gui'):
+    self.change_mode_gui("assist")
+```
+
+## 📊 Niveaux de Log
+
+- **"info"** : Information normale (gris)
+- **"success"** : Succès, événement positif (vert)
+- **"warning"** : Avertissement (orange)
+- **"error"** : Erreur (rouge)
+
+## 🎨 Emojis Recommandés
+
+- 👀 : Observation
+- 🎯 : Pattern détecté
+- 📚 : Workflow appris
+- ✅ : Succès, validation
+- 💡 : Suggestion
+- 🧠 : Fine-tuning, apprentissage
+- ⚠️ : Avertissement
+- ❌ : Erreur
+- 🚀 : Démarrage
+- ⏸ : Pause
+- ⏹ : Arrêt
+
+## 🧪 Tester
+
+Après avoir ajouté les logs, relancez :
+
+```bash
+./geniusia2/run.sh
+```
+
+Vous devriez voir :
+- ✅ Logs qui s'affichent dans la GUI
+- ✅ Statistiques qui se mettent à jour
+- ✅ Mode qui change
+
+## 📝 Exemple Complet
+
+Voici un exemple complet d'intégration dans une méthode :
+
+```python
+def process_action(self, action):
+    """Traite une action observée."""
+    try:
+        # 1. Incrémenter le compteur
+        self.actions_count += 1
+        
+        # 2. Logger vers la GUI
+        if hasattr(self, 'log_to_gui'):
+            self.log_to_gui("👀", f"Action dans {action.window}", "info")
+            self.update_gui_stats(actions_count=self.actions_count)
+        
+        # 3. Traiter l'action
+        result = self._process_action_internal(action)
+        
+        # 4. Si pattern détecté
+        if result.pattern_detected:
+            if hasattr(self, 'log_to_gui'):
+                self.log_to_gui("🎯", "Pattern détecté !", "success")
+                self.update_gui_stats(
+                    actions_count=self.actions_count,
+                    patterns_count=self.patterns_count
+                )
+        
+        return result
+        
+    except Exception as e:
+        # 5. En cas d'erreur
+        if hasattr(self, 'log_to_gui'):
+            self.log_to_gui("❌", f"Erreur: {str(e)}", "error")
+        raise
+```
+
+## 🎯 Priorités
+
+Pour avoir une GUI fonctionnelle rapidement, ajoutez au minimum :
+
+1. **Log au démarrage** (dans `run()`)
+2. **Log quand action observée** (dans la boucle principale)
+3. **Mise à jour du compteur d'actions**
+
+Ensuite, ajoutez progressivement :
+4. Patterns détectés
+5. Workflows appris
+6. Changements de mode
+7. Fine-tuning
+8. Erreurs
+
+## 💡 Astuce
+
+Pour tester rapidement, ajoutez un log de test au début de `run()` :
+
+```python
+def run(self):
+    # Test de connexion GUI
+    if hasattr(self, 'log_to_gui'):
+        self.log_to_gui("✅", "Orchestrator connecté à la GUI", "success")
+        print("✅ GUI connectée et fonctionnelle")
+    else:
+        print("⚠️ GUI non connectée")
+    
+    # Votre code normal...
+```
+
+---
+
+**Une fois les logs ajoutés, la GUI sera pleinement fonctionnelle ! 🚀**