Initial commit

geniusia2/gui/human_logger.py

@@ -0,0 +1,384 @@
+"""
+HumanLogger - Générateur de messages lisibles pour l'interface utilisateur
+Transforme les événements techniques en messages simples et contextuels.
+"""
+
+from datetime import datetime
+from typing import Optional, Dict, Any
+
+
+class HumanLogger:
+    """
+    Logger qui génère des messages simples et lisibles pour l'utilisateur.
+    
+    Transforme les événements techniques du système en messages compréhensibles
+    avec emojis et contexte approprié.
+    
+    Attributes:
+        first_time_events: Dictionnaire pour tracker les événements "première fois"
+    """
+    
+    def __init__(self):
+        """Initialise le HumanLogger avec tracking des premières fois."""
+        self.first_time_events: Dict[str, bool] = {
+            "workflow_detected": False,
+            "mode_change": False,
+            "pattern_detected": False,
+            "finetuning_started": False
+        }
+    
+    def log_observation(self, action_type: str, window: str) -> str:
+        """
+        Génère un message pour une action observée.
+        
+        Args:
+            action_type: Type d'action (click, type, scroll, etc.)
+            window: Nom de la fenêtre où l'action a eu lieu
+            
+        Returns:
+            Message formaté pour l'utilisateur
+            
+        Examples:
+            >>> logger = HumanLogger()
+            >>> logger.log_observation("click", "Calculator")
+            "👀 J'observe vos actions dans Calculator"
+        """
+        # Message simple et discret
+        return f"👀 J'observe vos actions dans {window}"
+    
+    def log_pattern_detected(self, repetitions: int, task_name: str) -> str:
+        """
+        Génère un message pour un pattern détecté.
+        
+        Args:
+            repetitions: Nombre de répétitions détectées
+            task_name: Nom de la tâche répétée
+            
+        Returns:
+            Message formaté avec contexte si première fois
+            
+        Examples:
+            >>> logger = HumanLogger()
+            >>> logger.log_pattern_detected(3, "Calculer 9/9")
+            "🎯 Tiens ! Vous avez fait 3 fois la même chose"
+        """
+        # Message d'excitation pour pattern détecté
+        message = f"🎯 Tiens ! Vous avez fait {repetitions} fois la même chose"
+        
+        # Ajouter contexte si première fois
+        if not self.first_time_events["pattern_detected"]:
+            self.first_time_events["pattern_detected"] = True
+            message += " (Je commence à apprendre vos habitudes)"
+        
+        return message
+    
+    def log_workflow_learned(self, task_name: str, count: int) -> str:
+        """
+        Génère un message pour un workflow appris.
+        
+        Args:
+            task_name: Nom du workflow appris
+            count: Nombre d'observations utilisées pour l'apprentissage
+            
+        Returns:
+            Message formaté avec explication si première fois
+            
+        Examples:
+            >>> logger = HumanLogger()
+            >>> logger.log_workflow_learned("Ouvrir facture", 5)
+            "📚 J'apprends: Ouvrir facture (5 observations)"
+        """
+        message = f"📚 J'apprends: {task_name} ({count} observations)"
+        
+        # Ajouter explication si première workflow
+        if not self.first_time_events["workflow_detected"]:
+            self.first_time_events["workflow_detected"] = True
+            message += "\n💡 Un workflow est une séquence d'actions que vous répétez"
+        
+        return message
+    
+    def log_mode_change(self, old_mode: str, new_mode: str, reason: Optional[str] = None) -> str:
+        """
+        Génère un message pour un changement de mode.
+        
+        Args:
+            old_mode: Mode précédent (shadow, assist, auto)
+            new_mode: Nouveau mode (shadow, assist, auto)
+            reason: Raison du changement (optionnel)
+            
+        Returns:
+            Message formaté avec explication du nouveau mode si première fois
+            
+        Examples:
+            >>> logger = HumanLogger()
+            >>> logger.log_mode_change("shadow", "assist")
+            "✅ Mode Suggestions activé"
+        """
+        # Mapper les modes techniques vers des noms lisibles
+        mode_names = {
+            "shadow": "Observation",
+            "assist": "Suggestions",
+            "copilot": "Copilote",
+            "auto": "Autonome"
+        }
+        
+        new_mode_name = mode_names.get(new_mode, new_mode)
+        message = f"✅ Mode {new_mode_name} activé"
+        
+        # Ajouter explication si premier changement de mode
+        if not self.first_time_events["mode_change"]:
+            self.first_time_events["mode_change"] = True
+            
+            # Expliquer ce que fait le nouveau mode
+            mode_explanations = {
+                "assist": "\n💡 Je vais maintenant vous suggérer des actions",
+                "copilot": "\n💡 Je peux maintenant exécuter avec votre validation",
+                "auto": "\n💡 Je peux maintenant agir de manière autonome"
+            }
+            
+            if new_mode in mode_explanations:
+                message += mode_explanations[new_mode]
+        
+        return message
+    
+    def log_finetuning_started(self, num_examples: int) -> str:
+        """
+        Génère un message pour le début du fine-tuning.
+        
+        Args:
+            num_examples: Nombre d'exemples utilisés pour le fine-tuning
+            
+        Returns:
+            Message formaté avec explication si première fois
+            
+        Examples:
+            >>> logger = HumanLogger()
+            >>> logger.log_finetuning_started(10)
+            "🧠 Amélioration du modèle (10 exemples)..."
+        """
+        message = f"🧠 Amélioration du modèle ({num_examples} exemples)..."
+        
+        # Ajouter explication si premier fine-tuning
+        if not self.first_time_events["finetuning_started"]:
+            self.first_time_events["finetuning_started"] = True
+            message += "\n💡 J'améliore ma compréhension de vos actions"
+        
+        return message
+    
+    def log_finetuning_completed(self, duration: float) -> str:
+        """
+        Génère un message pour la fin du fine-tuning.
+        
+        Args:
+            duration: Durée du fine-tuning en secondes
+            
+        Returns:
+            Message formaté de succès
+            
+        Examples:
+            >>> logger = HumanLogger()
+            >>> logger.log_finetuning_completed(2.5)
+            "✅ Modèle amélioré (en 2.5s)"
+        """
+        return f"✅ Modèle amélioré (en {duration:.1f}s)"
+    
+    def log_error(self, error_type: str, context: Optional[str] = None) -> str:
+        """
+        Génère un message d'erreur compréhensible avec suggestion d'action.
+        
+        Args:
+            error_type: Type d'erreur (connection, permission, not_found, etc.)
+            context: Contexte additionnel (optionnel)
+            
+        Returns:
+            Message d'erreur avec suggestion corrective
+            
+        Examples:
+            >>> logger = HumanLogger()
+            >>> logger.log_error("connection", "Calculator")
+            "⚠️ Impossible de se connecter à Calculator"
+        """
+        # Messages d'erreur avec suggestions
+        error_messages = {
+            "connection": "⚠️ Impossible de se connecter",
+            "permission": "⚠️ Permission refusée",
+            "not_found": "⚠️ Élément introuvable",
+            "timeout": "⚠️ Délai d'attente dépassé",
+            "whitelist": "⚠️ Application non autorisée",
+            "unknown": "⚠️ Une erreur est survenue"
+        }
+        
+        message = error_messages.get(error_type, error_messages["unknown"])
+        
+        # Ajouter contexte si fourni
+        if context:
+            message += f" - {context}"
+        
+        # Ajouter suggestion corrective selon le type d'erreur
+        suggestions = {
+            "connection": "\n💡 Vérifiez que l'application est ouverte",
+            "permission": "\n💡 Vérifiez les permissions de l'application",
+            "not_found": "\n💡 L'interface a peut-être changé",
+            "timeout": "\n💡 L'application est peut-être trop lente",
+            "whitelist": "\n💡 Ajoutez l'application à la liste autorisée"
+        }
+        
+        if error_type in suggestions:
+            message += suggestions[error_type]
+        
+        return message
+    
+    def log_idle(self) -> str:
+        """
+        Génère un message d'encouragement après inactivité.
+        
+        Returns:
+            Message d'encouragement
+            
+        Examples:
+            >>> logger = HumanLogger()
+            >>> logger.log_idle()
+            "💤 En attente de vos actions..."
+        """
+        return "💤 En attente de vos actions..."
+    
+    def log_stats_update(self, actions_count: int, patterns_count: int, workflows_count: int) -> str:
+        """
+        Génère un message de mise à jour des statistiques.
+        
+        Args:
+            actions_count: Nombre d'actions observées
+            patterns_count: Nombre de patterns détectés
+            workflows_count: Nombre de workflows appris
+            
+        Returns:
+            Message formaté avec statistiques
+            
+        Examples:
+            >>> logger = HumanLogger()
+            >>> logger.log_stats_update(12, 2, 1)
+            "📊 12 actions • 2 patterns • 1 workflow"
+        """
+        return f"📊 {actions_count} actions • {patterns_count} patterns • {workflows_count} workflow{'s' if workflows_count > 1 else ''}"
+    
+    def log_suggestion_ready(self, task_name: str) -> str:
+        """
+        Génère un message indiquant qu'une suggestion est prête.
+        
+        Args:
+            task_name: Nom de la tâche pour laquelle une suggestion est disponible
+            
+        Returns:
+            Message formaté
+            
+        Examples:
+            >>> logger = HumanLogger()
+            >>> logger.log_suggestion_ready("Ouvrir facture")
+            "💡 Prêt à suggérer: Ouvrir facture"
+        """
+        return f"💡 Prêt à suggérer: {task_name}"
+    
+    def log_collecting_examples(self, current: int, target: int) -> str:
+        """
+        Génère un message pour la collecte d'exemples de fine-tuning.
+        
+        Args:
+            current: Nombre d'exemples collectés
+            target: Nombre d'exemples cibles
+            
+        Returns:
+            Message formaté avec progression
+            
+        Examples:
+            >>> logger = HumanLogger()
+            >>> logger.log_collecting_examples(8, 10)
+            "🧠 Collecte d'exemples: 8/10"
+        """
+        return f"🧠 Collecte d'exemples: {current}/{target}"
+
+
+if __name__ == "__main__":
+    # Tests du HumanLogger
+    print("Test du HumanLogger")
+    print("=" * 50)
+    
+    logger = HumanLogger()
+    
+    # Test 1: Observation
+    print("\n1. Test log_observation:")
+    msg = logger.log_observation("click", "Calculator")
+    print(f"   {msg}")
+    
+    # Test 2: Pattern détecté (première fois)
+    print("\n2. Test log_pattern_detected (première fois):")
+    msg = logger.log_pattern_detected(3, "Calculer 9/9")
+    print(f"   {msg}")
+    
+    # Test 3: Pattern détecté (deuxième fois)
+    print("\n3. Test log_pattern_detected (deuxième fois):")
+    msg = logger.log_pattern_detected(4, "Ouvrir fichier")
+    print(f"   {msg}")
+    
+    # Test 4: Workflow appris (première fois)
+    print("\n4. Test log_workflow_learned (première fois):")
+    msg = logger.log_workflow_learned("Ouvrir facture", 5)
+    print(f"   {msg}")
+    
+    # Test 5: Workflow appris (deuxième fois)
+    print("\n5. Test log_workflow_learned (deuxième fois):")
+    msg = logger.log_workflow_learned("Calculer total", 3)
+    print(f"   {msg}")
+    
+    # Test 6: Changement de mode (première fois)
+    print("\n6. Test log_mode_change (première fois):")
+    msg = logger.log_mode_change("shadow", "assist")
+    print(f"   {msg}")
+    
+    # Test 7: Changement de mode (deuxième fois)
+    print("\n7. Test log_mode_change (deuxième fois):")
+    msg = logger.log_mode_change("assist", "auto")
+    print(f"   {msg}")
+    
+    # Test 8: Fine-tuning démarré (première fois)
+    print("\n8. Test log_finetuning_started (première fois):")
+    msg = logger.log_finetuning_started(10)
+    print(f"   {msg}")
+    
+    # Test 9: Fine-tuning démarré (deuxième fois)
+    print("\n9. Test log_finetuning_started (deuxième fois):")
+    msg = logger.log_finetuning_started(15)
+    print(f"   {msg}")
+    
+    # Test 10: Fine-tuning terminé
+    print("\n10. Test log_finetuning_completed:")
+    msg = logger.log_finetuning_completed(2.5)
+    print(f"    {msg}")
+    
+    # Test 11: Erreurs avec suggestions
+    print("\n11. Test log_error:")
+    for error_type in ["connection", "permission", "not_found", "timeout", "whitelist"]:
+        msg = logger.log_error(error_type, "Calculator")
+        print(f"    {msg}")
+        print()
+    
+    # Test 12: Idle
+    print("\n12. Test log_idle:")
+    msg = logger.log_idle()
+    print(f"    {msg}")
+    
+    # Test 13: Stats update
+    print("\n13. Test log_stats_update:")
+    msg = logger.log_stats_update(12, 2, 1)
+    print(f"    {msg}")
+    
+    # Test 14: Suggestion ready
+    print("\n14. Test log_suggestion_ready:")
+    msg = logger.log_suggestion_ready("Ouvrir facture")
+    print(f"    {msg}")
+    
+    # Test 15: Collecting examples
+    print("\n15. Test log_collecting_examples:")
+    msg = logger.log_collecting_examples(8, 10)
+    print(f"    {msg}")
+    
+    print("\n✓ Tous les tests manuels terminés!")