Geniusia_v2/docs/archive/old-summaries/AJOUTER_LOGS_ORCHESTRATOR.md

📝 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 :

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

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é

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

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

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

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

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 :

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 :

./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 :

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() :

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 ! 🚀