# 📝 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 ! 🚀**
