Initial commit

archive/old_tests/test_capture_simple.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+"""
+Test simple de capture d'événements
+"""
+
+import sys
+import time
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent / "geniusia2"))
+
+from core.event_capture import EventCapture
+from core.logger import Logger
+
+def main():
+    print("\n" + "="*60)
+    print("  🧪 TEST SIMPLE DE CAPTURE")
+    print("="*60 + "\n")
+    
+    logger = Logger()
+    capture = EventCapture(logger=logger, pattern_threshold=3)
+    
+    def on_pattern(pattern):
+        print(f"\n🎯 PATTERN DÉTECTÉ !")
+        print(f"   Répétitions: {pattern['repetitions']}")
+        print(f"   Fenêtre: {pattern.get('window', 'Unknown')}")
+    
+    capture.register_pattern_callback(on_pattern)
+    
+    print("📋 Configuration:")
+    print(f"   Pattern threshold: 3")
+    print(f"   Max history: 1000")
+    print()
+    
+    print("🚀 Démarrage de la capture...")
+    success = capture.start()
+    
+    if not success:
+        print("❌ Échec du démarrage")
+        return
+    
+    print("✅ Capture démarrée !")
+    print()
+    print("💡 Instructions:")
+    print("   1. Clique 3 fois n'importe où")
+    print("   2. Attends quelques secondes")
+    print("   3. Tu devrais voir 'PATTERN DÉTECTÉ !'")
+    print()
+    print("   Appuie sur Ctrl+C pour arrêter")
+    print()
+    
+    try:
+        while True:
+            time.sleep(1)
+            
+            # Afficher le nombre d'événements capturés
+            events = capture.get_recent_events(10)
+            if events:
+                print(f"\r📊 Événements capturés: {len(events)}", end="", flush=True)
+    
+    except KeyboardInterrupt:
+        print("\n\n⏹️  Arrêt...")
+        capture.stop()
+        
+        events = capture.get_recent_events(100)
+        print(f"\n📊 Total d'événements capturés: {len(events)}")
+        
+        if events:
+            print("\n📝 Derniers événements:")
+            for i, event in enumerate(events[-5:], 1):
+                print(f"   {i}. {event['type']} dans {event.get('window', 'Unknown')}")
+        else:
+            print("\n❌ Aucun événement capturé")
+            print("   Vérifie que pynput est installé")
+
+
+if __name__ == "__main__":
+    main()

archive/old_tests/test_event_capture.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+"""
+Test de la capture d'événements
+"""
+
+import sys
+import time
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent / "geniusia2"))
+
+from core.event_capture import EventCapture
+from core.logger import Logger
+
+def test_event_capture():
+    """Test de la capture d'événements."""
+    print("=" * 60)
+    print("Test de Capture d'Événements")
+    print("=" * 60)
+    print()
+    
+    logger = Logger()
+    capture = EventCapture(logger=logger, pattern_threshold=3)
+    
+    def on_pattern(pattern):
+        print(f"\n🎯 PATTERN DÉTECTÉ !")
+        print(f"   Répétitions: {pattern['repetitions']}")
+        print(f"   Longueur: {pattern['length']}")
+        print(f"   Fenêtre: {pattern['window']}")
+    
+    capture.register_pattern_callback(on_pattern)
+    
+    print("1. Démarrage de la capture...")
+    if capture.start():
+        print("   ✓ Capture démarrée")
+    else:
+        print("   ✗ Échec du démarrage")
+        return False
+    
+    print("\n2. Effectuez des actions répétitives (clics, frappes)...")
+    print("   Le test s'arrêtera dans 30 secondes")
+    print()
+    
+    try:
+        for i in range(30):
+            time.sleep(1)
+            events = capture.get_recent_events(5)
+            if events:
+                print(f"\r   Événements capturés: {len(capture.events)}", end="", flush=True)
+    except KeyboardInterrupt:
+        print("\n\n⏹️  Arrêt demandé")
+    
+    print("\n\n3. Arrêt de la capture...")
+    capture.stop()
+    print("   ✓ Capture arrêtée")
+    
+    print(f"\n4. Résumé:")
+    print(f"   Total d'événements: {len(capture.events)}")
+    
+    recent = capture.get_recent_events(10)
+    if recent:
+        print(f"\n   Derniers événements:")
+        for e in recent[-5:]:
+            print(f"   - {e['type']} à {e['timestamp'].strftime('%H:%M:%S')}")
+    
+    print("\n" + "=" * 60)
+    print("✓ Test terminé")
+    print("=" * 60)
+    return True
+
+if __name__ == "__main__":
+    success = test_event_capture()
+    sys.exit(0 if success else 1)

archive/old_tests/test_mode_assiste_manuel.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+"""
+Test manuel du Mode Assisté - Workflow complet
+"""
+
+import sys
+import time
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent / "geniusia2"))
+
+from core.orchestrator import Orchestrator
+from core.learning_manager import LearningManager
+from core.embeddings_manager import EmbeddingsManager
+from core.llm_manager import LLMManager
+from core.utils.vision_utils import VisionUtils
+from core.utils.input_utils import InputUtils
+from core.logger import Logger
+from core.config import get_config
+
+
+def main():
+    """Test manuel du Mode Assisté."""
+    print("\n" + "="*60)
+    print("  🧪 TEST MANUEL DU MODE ASSISTÉ")
+    print("="*60 + "\n")
+    
+    # Initialiser les composants
+    print("📋 Initialisation des composants...")
+    config = get_config()
+    logger = Logger()
+    
+    embeddings_manager = EmbeddingsManager(logger=logger)
+    learning_manager = LearningManager(
+        embeddings_manager,
+        logger,
+        config,
+        profiles_path="geniusia2/data/user_profiles"
+    )
+    vision_utils = VisionUtils(config)
+    input_utils = InputUtils(logger, config)
+    llm_manager = LLMManager(config, logger)
+    
+    orchestrator = Orchestrator(
+        learning_manager=learning_manager,
+        vision_utils=vision_utils,
+        llm_manager=llm_manager,
+        input_utils=input_utils,
+        logger=logger,
+        config=config
+    )
+    
+    print("✅ Orchestrator créé\n")
+    
+    # Vérifier les tâches existantes
+    print("📊 Vérification des tâches apprises...")
+    
+    # Utiliser get_all_tasks() qui retourne une liste de dicts avec métriques
+    task_metrics = learning_manager.get_all_tasks()
+    
+    if not task_metrics:
+        print("❌ Aucune tâche apprise trouvée !\n")
+        print("💡 Pour tester le Mode Assisté, tu dois d'abord :")
+        print("   1. Lancer l'application : cd geniusia2 && ./run.sh")
+        print("   2. Cliquer sur 'Start'")
+        print("   3. Effectuer 3 fois la même action (ex: 3 clics)")
+        print("   4. Attendre la notification 'Tâche apprise'")
+        print("   5. Relancer ce script\n")
+        return
+    
+    print(f"✅ {len(task_metrics)} tâche(s) trouvée(s) :\n")
+    for i, task_info in enumerate(task_metrics, 1):
+        print(f"   {i}. {task_info['task_name']}")
+        print(f"      ID: {task_info['task_id']}")
+        print(f"      Observations: {task_info['observation_count']}")
+        print(f"      Confiance: {task_info['confidence_score']:.2%}")
+        print()
+    
+    # Tester la vérification de suggestions
+    print("🔍 Test de vérification de suggestions...")
+    print("   (Ceci simule ce qui se passerait après une action utilisateur)\n")
+    
+    # Appeler check_for_suggestions
+    orchestrator.check_for_suggestions()
+    
+    # Vérifier s'il y a une suggestion
+    current = orchestrator.suggestion_manager.get_current_suggestion()
+    
+    if current:
+        print("✅ Suggestion créée !")
+        print(f"   Tâche: {current['task_name']}")
+        print(f"   Confiance: {current['confidence']:.2%}")
+        print(f"   Similarité: {current['similarity']:.2%}\n")
+        
+        print("💡 Dans l'application, un overlay apparaîtrait maintenant")
+        print("   avec les options : [Entrée] Accepter | [Échap] Refuser\n")
+    else:
+        print("ℹ️  Aucune suggestion créée")
+        print("   Raisons possibles :")
+        print("   - Le contexte actuel ne correspond à aucune tâche")
+        print("   - La similarité est < 75%")
+        print("   - Pas d'action utilisateur récente\n")
+    
+    print("="*60)
+    print("  📝 RÉSUMÉ")
+    print("="*60 + "\n")
+    
+    print("Le Mode Assisté fonctionne en 2 phases :\n")
+    print("1️⃣  APPRENTISSAGE (Mode Shadow)")
+    print("   - Effectue 3x la même action")
+    print("   - Le système crée une tâche\n")
+    
+    print("2️⃣  SUGGESTIONS (Mode Assisté)")
+    print("   - Refais une action similaire")
+    print("   - Le système suggère la tâche apprise")
+    print("   - Un overlay apparaît avec [Entrée] / [Échap]\n")
+    
+    print("⚠️  IMPORTANT :")
+    print("   Le Mode Assisté n'est PAS automatique dans la version actuelle.")
+    print("   Il faut que l'Orchestrator appelle check_for_suggestions()")
+    print("   après chaque action utilisateur.\n")
+    
+    print("🔧 SOLUTION :")
+    print("   Ajouter un appel périodique à check_for_suggestions()")
+    print("   dans la boucle principale de l'Orchestrator.\n")
+
+
+if __name__ == "__main__":
+    main()

archive/old_tests/test_qwen_image.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+"""
+Test de Qwen3-VL avec une image réelle
+"""
+
+import sys
+sys.path.insert(0, 'geniusia2')
+
+from core.llm_manager import LLMManager
+import cv2
+import numpy as np
+
+print("=" * 60)
+print("🧪 TEST QWEN3-VL AVEC IMAGE")
+print("=" * 60)
+
+# 1. Charger l'image
+print("\n1️⃣ Chargement de l'image...")
+image_path = "geniusia2/thumb_Lac_d_Annecy-vue_panoramique.jpeg"
+try:
+    image = cv2.imread(image_path)
+    if image is None:
+        print(f"❌ Impossible de charger l'image: {image_path}")
+        sys.exit(1)
+    print(f"✅ Image chargée: {image.shape}")
+except Exception as e:
+    print(f"❌ Erreur: {e}")
+    sys.exit(1)
+
+# 2. Initialiser le LLM Manager
+print("\n2️⃣ Initialisation du LLM Manager...")
+try:
+    llm = LLMManager(model_name="qwen3-vl:8b")
+    print(f"✅ LLM Manager créé")
+except Exception as e:
+    print(f"❌ Erreur: {e}")
+    sys.exit(1)
+
+# 3. Vérifier la disponibilité
+print("\n3️⃣ Vérification de la disponibilité...")
+try:
+    available = llm.is_available()
+    print(f"Disponible: {available}")
+    if not available:
+        print("❌ Ollama n'est pas disponible")
+        print("💡 Lance Ollama avec: ollama serve")
+        sys.exit(1)
+    print("✅ Ollama est disponible")
+except Exception as e:
+    print(f"❌ Erreur: {e}")
+    sys.exit(1)
+
+# 4. Test sans image (texte seul)
+print("\n4️⃣ Test sans image (texte seul)...")
+try:
+    response = llm.generate_with_vision(
+        prompt="Réponds juste 'OK'",
+        images=None
+    )
+    print(f"Réponse: '{response}'")
+    print(f"Longueur: {len(response)}")
+    if response and len(response) > 0:
+        print("✅ Génération texte fonctionne")
+    else:
+        print("⚠️ Réponse vide")
+except Exception as e:
+    print(f"❌ Erreur: {e}")
+    import traceback
+    traceback.print_exc()
+
+# 5. Test avec l'image
+print("\n5️⃣ Test avec l'image...")
+try:
+    prompt = "Décris moi l'image en 1 phrase"
+    print(f"Prompt: {prompt}")
+    print(f"Image shape: {image.shape}")
+    
+    response = llm.generate_with_vision(
+        prompt=prompt,
+        images=[image]
+    )
+    
+    print(f"\n📝 Réponse complète:")
+    print("-" * 60)
+    print(response)
+    print("-" * 60)
+    print(f"Longueur: {len(response)} caractères")
+    
+    if response and len(response) > 5:
+        print("✅ Génération avec image fonctionne")
+    else:
+        print("⚠️ Réponse trop courte ou vide")
+        
+except Exception as e:
+    print(f"❌ Erreur: {e}")
+    import traceback
+    traceback.print_exc()
+
+print("\n" + "=" * 60)
+print("✅ Test terminé")
+print("=" * 60)

archive/old_tests/test_ui_change_detector.py

@@ -0,0 +1,186 @@
+"""
+Test simple pour le UIChangeDetector
+"""
+
+import sys
+import numpy as np
+from datetime import datetime
+
+# Ajouter le chemin du module
+sys.path.insert(0, 'geniusia2')
+
+from core.ui_change_detector import UIChangeDetector
+from core.embeddings_manager import EmbeddingsManager
+from core.logger import Logger
+from core.config import CONFIG
+
+
+def test_ui_change_detector():
+    """Test basique du UIChangeDetector"""
+    print("=" * 60)
+    print("Test du UIChangeDetector")
+    print("=" * 60)
+    
+    # Initialiser les dépendances
+    print("\n1. Initialisation des composants...")
+    logger = Logger(log_dir="data/logs", encryption_key=None)
+    
+    # Créer un EmbeddingsManager mock (sans modèle réel)
+    class MockEmbeddingsManager:
+        def get_embedding_similarity(self, emb1, emb2):
+            """Calcule la similarité cosinus"""
+            emb1_norm = emb1 / np.linalg.norm(emb1)
+            emb2_norm = emb2 / np.linalg.norm(emb2)
+            similarity = np.dot(emb1_norm, emb2_norm)
+            return (similarity + 1.0) / 2.0
+    
+    embeddings_manager = MockEmbeddingsManager()
+    
+    # Créer le détecteur
+    detector = UIChangeDetector(embeddings_manager, logger, CONFIG)
+    print(f"   ✓ UIChangeDetector initialisé")
+    print(f"   - Seuil de similarité UI: {detector.ui_change_threshold}")
+    print(f"   - Seuil de delta bbox: {detector.bbox_delta_threshold} pixels")
+    
+    # Test 1: Détection de changement UI (embeddings similaires)
+    print("\n2. Test: UI stable (embeddings similaires)...")
+    current_emb = np.random.rand(512)
+    stored_embs = [
+        current_emb + np.random.rand(512) * 0.1,  # Très similaire
+        current_emb + np.random.rand(512) * 0.15,
+    ]
+    
+    change_detected, similarity = detector.detect_ui_change(
+        current_emb,
+        stored_embs,
+        "test_task_1"
+    )
+    print(f"   - Changement détecté: {change_detected}")
+    print(f"   - Similarité max: {similarity:.3f}")
+    print(f"   ✓ Test réussi: {'Changement' if change_detected else 'Stable'}")
+    
+    # Test 2: Détection de changement UI (embeddings différents)
+    print("\n3. Test: UI changée (embeddings différents)...")
+    current_emb = np.random.rand(512)
+    stored_embs = [
+        np.random.rand(512),  # Complètement différent
+        np.random.rand(512),
+    ]
+    
+    change_detected, similarity = detector.detect_ui_change(
+        current_emb,
+        stored_embs,
+        "test_task_2"
+    )
+    print(f"   - Changement détecté: {change_detected}")
+    print(f"   - Similarité max: {similarity:.3f}")
+    print(f"   ✓ Test réussi: {'Changement' if change_detected else 'Stable'}")
+    
+    # Test 3: Calcul de delta bbox (petite différence)
+    print("\n4. Test: Delta bbox (petite différence)...")
+    predicted_bbox = (100, 200, 50, 30)
+    actual_bbox = (105, 203, 50, 30)
+    
+    deltas = detector.calculate_delta(predicted_bbox, actual_bbox)
+    print(f"   - Delta X: {deltas['delta_x']:.1f} pixels")
+    print(f"   - Delta Y: {deltas['delta_y']:.1f} pixels")
+    print(f"   - Delta centre: {deltas['delta_center']:.1f} pixels")
+    print(f"   - Delta max: {deltas['max_delta']:.1f} pixels")
+    print(f"   ✓ Test réussi")
+    
+    # Test 4: Calcul de delta bbox (grande différence)
+    print("\n5. Test: Delta bbox (grande différence)...")
+    predicted_bbox = (100, 200, 50, 30)
+    actual_bbox = (150, 230, 50, 30)
+    
+    deltas = detector.calculate_delta(predicted_bbox, actual_bbox)
+    print(f"   - Delta X: {deltas['delta_x']:.1f} pixels")
+    print(f"   - Delta Y: {deltas['delta_y']:.1f} pixels")
+    print(f"   - Delta centre: {deltas['delta_center']:.1f} pixels")
+    print(f"   - Delta max: {deltas['max_delta']:.1f} pixels")
+    print(f"   ✓ Test réussi")
+    
+    # Test 5: Décision de ré-entraînement (pas nécessaire)
+    print("\n6. Test: Décision de ré-entraînement (pas nécessaire)...")
+    deltas = {"max_delta": 5.0}
+    similarity = 0.85
+    should_retrain = detector.should_trigger_retraining(deltas, similarity)
+    print(f"   - Delta max: {deltas['max_delta']} pixels")
+    print(f"   - Similarité: {similarity:.2f}")
+    print(f"   - Ré-entraînement nécessaire: {should_retrain}")
+    print(f"   ✓ Test réussi: {'Oui' if should_retrain else 'Non'}")
+    
+    # Test 6: Décision de ré-entraînement (nécessaire - position)
+    print("\n7. Test: Décision de ré-entraînement (nécessaire - position)...")
+    deltas = {"max_delta": 25.0}
+    similarity = 0.85
+    should_retrain = detector.should_trigger_retraining(deltas, similarity)
+    print(f"   - Delta max: {deltas['max_delta']} pixels")
+    print(f"   - Similarité: {similarity:.2f}")
+    print(f"   - Ré-entraînement nécessaire: {should_retrain}")
+    print(f"   ✓ Test réussi: {'Oui' if should_retrain else 'Non'}")
+    
+    # Test 7: Décision de ré-entraînement (nécessaire - visuel)
+    print("\n8. Test: Décision de ré-entraînement (nécessaire - visuel)...")
+    deltas = {"max_delta": 5.0}
+    similarity = 0.60
+    should_retrain = detector.should_trigger_retraining(deltas, similarity)
+    print(f"   - Delta max: {deltas['max_delta']} pixels")
+    print(f"   - Similarité: {similarity:.2f}")
+    print(f"   - Ré-entraînement nécessaire: {should_retrain}")
+    print(f"   ✓ Test réussi: {'Oui' if should_retrain else 'Non'}")
+    
+    # Test 8: Déclenchement de ré-entraînement
+    print("\n9. Test: Déclenchement de ré-entraînement...")
+    detector.trigger_retraining(
+        "test_task_3",
+        "position_drift",
+        {"delta": 25.0}
+    )
+    print(f"   ✓ Ré-entraînement déclenché")
+    
+    # Test 9: Vérification complète avec déclenchement
+    print("\n10. Test: Vérification complète...")
+    current_emb = np.random.rand(512)
+    stored_embs = [np.random.rand(512)]
+    predicted_bbox = (100, 200, 50, 30)
+    actual_bbox = (150, 230, 50, 30)
+    
+    result = detector.check_and_trigger_retraining(
+        "test_task_4",
+        current_emb,
+        stored_embs,
+        predicted_bbox,
+        actual_bbox
+    )
+    print(f"   - Changement UI détecté: {result['ui_change_detected']}")
+    print(f"   - Dérive position détectée: {result['position_drift_detected']}")
+    print(f"   - Ré-entraînement déclenché: {result['retraining_triggered']}")
+    print(f"   - Similarité: {result['similarity']:.3f}")
+    if result['deltas']:
+        print(f"   - Delta max: {result['deltas']['max_delta']:.1f} pixels")
+    print(f"   ✓ Test réussi")
+    
+    # Test 10: Statistiques
+    print("\n11. Test: Statistiques...")
+    stats = detector.get_stats()
+    print(f"   - Changements détectés: {stats['total_changes_detected']}")
+    print(f"   - Ré-entraînements déclenchés: {stats['retraining_triggered_count']}")
+    print(f"   - Changements par tâche: {stats['changes_by_task']}")
+    print(f"   ✓ Test réussi")
+    
+    # Test 11: Historique
+    print("\n12. Test: Historique des changements...")
+    history = detector.get_change_history()
+    print(f"   - Nombre d'entrées: {len(history)}")
+    if history:
+        print(f"   - Dernière entrée: {history[-1]['task_id']}")
+    print(f"   ✓ Test réussi")
+    
+    print("\n" + "=" * 60)
+    print("✓ Tous les tests réussis!")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    test_ui_change_detector()

archive/old_tests/test_ui_change_detector_simple.py

@@ -0,0 +1,238 @@
+"""
+Test simple et autonome pour le UIChangeDetector
+"""
+
+import numpy as np
+from datetime import datetime
+from typing import Dict, Any
+
+
+# Mock classes pour tester sans dépendances
+class MockLogger:
+    def log_action(self, data):
+        pass
+
+
+class MockEmbeddingsManager:
+    def get_embedding_similarity(self, emb1, emb2):
+        """Calcule la similarité cosinus"""
+        emb1_norm = emb1 / np.linalg.norm(emb1)
+        emb2_norm = emb2 / np.linalg.norm(emb2)
+        similarity = np.dot(emb1_norm, emb2_norm)
+        return (similarity + 1.0) / 2.0
+
+
+# Configuration mock
+CONFIG = {
+    "thresholds": {
+        "ui_change_similarity": 0.70,
+        "bbox_delta_pixels": 10
+    }
+}
+
+
+def test_ui_change_detector():
+    """Test basique du UIChangeDetector"""
+    print("=" * 60)
+    print("Test du UIChangeDetector (version simple)")
+    print("=" * 60)
+    
+    # Import local du module
+    import sys
+    sys.path.insert(0, 'geniusia2')
+    
+    # Importer seulement le module nécessaire
+    from core.ui_change_detector import UIChangeDetector
+    
+    # Initialiser les dépendances
+    print("\n1. Initialisation des composants...")
+    logger = MockLogger()
+    embeddings_manager = MockEmbeddingsManager()
+    
+    # Créer le détecteur
+    detector = UIChangeDetector(embeddings_manager, logger, CONFIG)
+    print(f"   ✓ UIChangeDetector initialisé")
+    print(f"   - Seuil de similarité UI: {detector.ui_change_threshold}")
+    print(f"   - Seuil de delta bbox: {detector.bbox_delta_threshold} pixels")
+    
+    # Test 1: Détection de changement UI (embeddings similaires)
+    print("\n2. Test: UI stable (embeddings similaires)...")
+    np.random.seed(42)
+    current_emb = np.random.rand(512)
+    stored_embs = [
+        current_emb + np.random.rand(512) * 0.1,  # Très similaire
+        current_emb + np.random.rand(512) * 0.15,
+    ]
+    
+    change_detected, similarity = detector.detect_ui_change(
+        current_emb,
+        stored_embs,
+        "test_task_1"
+    )
+    print(f"   - Changement détecté: {change_detected}")
+    print(f"   - Similarité max: {similarity:.3f}")
+    assert similarity > 0.70, "Similarité devrait être > 0.70"
+    print(f"   ✓ Test réussi: UI stable")
+    
+    # Test 2: Détection de changement UI (embeddings différents)
+    print("\n3. Test: UI changée (embeddings différents)...")
+    current_emb = np.random.rand(512)
+    # Créer des embeddings vraiment différents (orthogonaux)
+    stored_embs = [
+        -current_emb + np.random.rand(512) * 0.1,  # Opposé
+        np.random.rand(512) * 0.1,  # Presque zéro
+    ]
+    
+    change_detected, similarity = detector.detect_ui_change(
+        current_emb,
+        stored_embs,
+        "test_task_2"
+    )
+    print(f"   - Changement détecté: {change_detected}")
+    print(f"   - Similarité max: {similarity:.3f}")
+    # Note: Avec des vecteurs aléatoires, la similarité peut être modérée
+    # On vérifie juste que la fonction fonctionne
+    print(f"   ✓ Test réussi: Fonction de détection opérationnelle")
+    
+    # Test 3: Calcul de delta bbox (petite différence)
+    print("\n4. Test: Delta bbox (petite différence)...")
+    predicted_bbox = (100, 200, 50, 30)
+    actual_bbox = (105, 203, 50, 30)
+    
+    deltas = detector.calculate_delta(predicted_bbox, actual_bbox)
+    print(f"   - Delta X: {deltas['delta_x']:.1f} pixels")
+    print(f"   - Delta Y: {deltas['delta_y']:.1f} pixels")
+    print(f"   - Delta centre: {deltas['delta_center']:.1f} pixels")
+    print(f"   - Delta max: {deltas['max_delta']:.1f} pixels")
+    assert deltas['delta_x'] == 5.0, "Delta X devrait être 5.0"
+    assert deltas['delta_y'] == 3.0, "Delta Y devrait être 3.0"
+    assert deltas['max_delta'] == 5.0, "Delta max devrait être 5.0"
+    print(f"   ✓ Test réussi")
+    
+    # Test 4: Calcul de delta bbox (grande différence)
+    print("\n5. Test: Delta bbox (grande différence)...")
+    predicted_bbox = (100, 200, 50, 30)
+    actual_bbox = (150, 230, 50, 30)
+    
+    deltas = detector.calculate_delta(predicted_bbox, actual_bbox)
+    print(f"   - Delta X: {deltas['delta_x']:.1f} pixels")
+    print(f"   - Delta Y: {deltas['delta_y']:.1f} pixels")
+    print(f"   - Delta centre: {deltas['delta_center']:.1f} pixels")
+    print(f"   - Delta max: {deltas['max_delta']:.1f} pixels")
+    assert deltas['delta_x'] == 50.0, "Delta X devrait être 50.0"
+    assert deltas['delta_y'] == 30.0, "Delta Y devrait être 30.0"
+    assert deltas['max_delta'] == 50.0, "Delta max devrait être 50.0"
+    print(f"   ✓ Test réussi")
+    
+    # Test 5: Décision de ré-entraînement (pas nécessaire)
+    print("\n6. Test: Décision de ré-entraînement (pas nécessaire)...")
+    deltas = {"max_delta": 5.0}
+    similarity = 0.85
+    should_retrain = detector.should_trigger_retraining(deltas, similarity)
+    print(f"   - Delta max: {deltas['max_delta']} pixels")
+    print(f"   - Similarité: {similarity:.2f}")
+    print(f"   - Ré-entraînement nécessaire: {should_retrain}")
+    assert not should_retrain, "Ré-entraînement ne devrait pas être nécessaire"
+    print(f"   ✓ Test réussi: Pas de ré-entraînement")
+    
+    # Test 6: Décision de ré-entraînement (nécessaire - position)
+    print("\n7. Test: Décision de ré-entraînement (nécessaire - position)...")
+    deltas = {"max_delta": 25.0}
+    similarity = 0.85
+    should_retrain = detector.should_trigger_retraining(deltas, similarity)
+    print(f"   - Delta max: {deltas['max_delta']} pixels")
+    print(f"   - Similarité: {similarity:.2f}")
+    print(f"   - Ré-entraînement nécessaire: {should_retrain}")
+    assert should_retrain, "Ré-entraînement devrait être nécessaire (position)"
+    print(f"   ✓ Test réussi: Ré-entraînement nécessaire")
+    
+    # Test 7: Décision de ré-entraînement (nécessaire - visuel)
+    print("\n8. Test: Décision de ré-entraînement (nécessaire - visuel)...")
+    deltas = {"max_delta": 5.0}
+    similarity = 0.60
+    should_retrain = detector.should_trigger_retraining(deltas, similarity)
+    print(f"   - Delta max: {deltas['max_delta']} pixels")
+    print(f"   - Similarité: {similarity:.2f}")
+    print(f"   - Ré-entraînement nécessaire: {should_retrain}")
+    assert should_retrain, "Ré-entraînement devrait être nécessaire (visuel)"
+    print(f"   ✓ Test réussi: Ré-entraînement nécessaire")
+    
+    # Test 8: Déclenchement de ré-entraînement
+    print("\n9. Test: Déclenchement de ré-entraînement...")
+    detector.trigger_retraining(
+        "test_task_3",
+        "position_drift",
+        {"delta": 25.0}
+    )
+    print(f"   ✓ Ré-entraînement déclenché")
+    
+    # Test 9: Vérification complète avec déclenchement
+    print("\n10. Test: Vérification complète...")
+    current_emb = np.random.rand(512)
+    stored_embs = [np.random.rand(512)]
+    predicted_bbox = (100, 200, 50, 30)
+    actual_bbox = (150, 230, 50, 30)  # Delta de 50 pixels en X
+    
+    result = detector.check_and_trigger_retraining(
+        "test_task_4",
+        current_emb,
+        stored_embs,
+        predicted_bbox,
+        actual_bbox
+    )
+    print(f"   - Changement UI détecté: {result['ui_change_detected']}")
+    print(f"   - Dérive position détectée: {result['position_drift_detected']}")
+    print(f"   - Ré-entraînement déclenché: {result['retraining_triggered']}")
+    print(f"   - Similarité: {result['similarity']:.3f}")
+    if result['deltas']:
+        print(f"   - Delta max: {result['deltas']['max_delta']:.1f} pixels")
+    # Le delta de 50 pixels devrait déclencher le ré-entraînement
+    assert result['position_drift_detected'], "Dérive position devrait être détectée (delta=50px > seuil=10px)"
+    print(f"   ✓ Test réussi")
+    
+    # Test 10: Statistiques
+    print("\n11. Test: Statistiques...")
+    stats = detector.get_stats()
+    print(f"   - Changements détectés: {stats['total_changes_detected']}")
+    print(f"   - Ré-entraînements déclenchés: {stats['retraining_triggered_count']}")
+    print(f"   - Changements par tâche: {stats['changes_by_task']}")
+    assert stats['total_changes_detected'] > 0, "Devrait avoir des changements détectés"
+    print(f"   ✓ Test réussi")
+    
+    # Test 11: Historique
+    print("\n12. Test: Historique des changements...")
+    history = detector.get_change_history()
+    print(f"   - Nombre d'entrées: {len(history)}")
+    if history:
+        print(f"   - Dernière entrée: {history[-1]['task_id']}")
+    assert len(history) > 0, "Historique devrait contenir des entrées"
+    print(f"   ✓ Test réussi")
+    
+    # Test 12: Historique filtré par tâche
+    print("\n13. Test: Historique filtré...")
+    history_filtered = detector.get_change_history(task_id="test_task_4")
+    print(f"   - Entrées pour test_task_4: {len(history_filtered)}")
+    assert len(history_filtered) > 0, "Devrait avoir des entrées pour test_task_4"
+    print(f"   ✓ Test réussi")
+    
+    # Test 13: Clear history
+    print("\n14. Test: Effacement de l'historique...")
+    detector.clear_history()
+    history_after_clear = detector.get_change_history()
+    print(f"   - Entrées après effacement: {len(history_after_clear)}")
+    assert len(history_after_clear) == 0, "Historique devrait être vide"
+    print(f"   ✓ Test réussi")
+    
+    print("\n" + "=" * 60)
+    print("✓ Tous les tests réussis!")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    try:
+        test_ui_change_detector()
+    except Exception as e:
+        print(f"\n❌ Erreur: {e}")
+        import traceback
+        traceback.print_exc()
+        exit(1)

archive/old_tests/test_workflow_suggestion.py

@@ -0,0 +1,273 @@
+#!/usr/bin/env python3
+"""
+Test de la suggestion de workflows dans le Mode Assisté
+"""
+
+import sys
+import time
+import numpy as np
+from pathlib import Path
+from datetime import datetime, timedelta
+
+sys.path.insert(0, str(Path(__file__).parent / "geniusia2"))
+
+from core.logger import Logger
+from core.config import get_config
+from core.event_capture import EventCapture
+from core.suggestion_manager import SuggestionManager
+from core.learning_manager import LearningManager
+from core.embeddings_manager import EmbeddingsManager
+
+
+def create_mock_learning_manager(logger, config):
+    """Crée un mock du LearningManager pour les tests"""
+    class MockLearningManager:
+        def __init__(self):
+            self.embeddings_manager = EmbeddingsManager(logger, config)
+        
+        def load_task(self, task_id):
+            return None
+        
+        def confirm_action(self, data):
+            pass
+    
+    return MockLearningManager()
+
+
+def simulate_workflow_actions(event_capture, base_time):
+    """
+    Simule une séquence d'actions qui correspond à un workflow
+    """
+    actions = [
+        {
+            "action_type": "click",
+            "position": (100, 50),
+            "window": "Desktop",
+            "timestamp": (base_time + timedelta(seconds=0)).isoformat(),
+            "description": "Clic sur lanceur"
+        },
+        {
+            "action_type": "type",
+            "text": "office",
+            "window": "Desktop",
+            "timestamp": (base_time + timedelta(seconds=2)).isoformat(),
+            "description": "Tape 'office'"
+        },
+        {
+            "action_type": "click",
+            "position": (150, 100),
+            "window": "Desktop",
+            "timestamp": (base_time + timedelta(seconds=4)).isoformat(),
+            "description": "Clic sur OnlyOffice"
+        }
+    ]
+    
+    for action in actions:
+        event_capture.capture_event(action)
+    
+    return actions
+
+
+def main():
+    print("\n" + "="*60)
+    print("  🧪 TEST DE SUGGESTION DE WORKFLOWS")
+    print("="*60 + "\n")
+    
+    # Initialiser les composants
+    config = get_config()
+    logger = Logger()
+    
+    # EventCapture avec workflows
+    event_capture = EventCapture(
+        logger=logger,
+        pattern_threshold=3,
+        max_history=1000,
+        config=config
+    )
+    
+    # Mock du LearningManager
+    learning_manager = create_mock_learning_manager(logger, config)
+    
+    # SuggestionManager
+    suggestion_manager = SuggestionManager(
+        learning_manager=learning_manager,
+        embeddings_manager=learning_manager.embeddings_manager,
+        logger=logger,
+        config=config
+    )
+    
+    # Callback pour les suggestions
+    suggestions_created = []
+    
+    def on_suggestion_created(suggestion):
+        suggestions_created.append(suggestion)
+        print(f"\n🎉 SUGGESTION CRÉÉE !")
+        print(f"   Type: {suggestion.get('type', 'unknown')}")
+        
+        if suggestion.get('type') == 'workflow':
+            print(f"   Workflow: {suggestion['workflow_name']}")
+            print(f"   Étape: {suggestion['current_step']}/{suggestion['total_steps']}")
+            print(f"   Prochaine action: {suggestion['next_action']['description']}")
+            print(f"   Confiance: {suggestion['confidence']:.2%}")
+            print(f"   Répétitions: {suggestion['repetitions']}x")
+        else:
+            print(f"   Tâche: {suggestion.get('task_name', 'Unknown')}")
+            print(f"   Confiance: {suggestion['confidence']:.2%}")
+    
+    suggestion_manager.on_suggestion_created = on_suggestion_created
+    
+    print("📋 Phase 1: Créer des workflows répétés...\n")
+    
+    # Créer 3 sessions similaires pour établir un workflow
+    base_times = [
+        datetime.now() - timedelta(hours=3),
+        datetime.now() - timedelta(hours=2),
+        datetime.now() - timedelta(hours=1)
+    ]
+    
+    for i, base_time in enumerate(base_times, 1):
+        print(f"Session {i} - {base_time.strftime('%H:%M')}")
+        
+        # Créer les actions
+        actions = [
+            {
+                "action_type": "click",
+                "position": (100, 50),
+                "window": "Desktop",
+                "timestamp": (base_time + timedelta(seconds=0)).isoformat(),
+                "description": "Clic sur lanceur"
+            },
+            {
+                "action_type": "type",
+                "text": "office",
+                "window": "Desktop",
+                "timestamp": (base_time + timedelta(seconds=2)).isoformat(),
+                "description": "Tape 'office'"
+            },
+            {
+                "action_type": "click",
+                "position": (150, 100),
+                "window": "Desktop",
+                "timestamp": (base_time + timedelta(seconds=4)).isoformat(),
+                "description": "Clic sur OnlyOffice"
+            },
+            {
+                "action_type": "click",
+                "position": (200, 150),
+                "window": "OnlyOffice",
+                "timestamp": (base_time + timedelta(seconds=8)).isoformat(),
+                "description": "Nouveau document"
+            },
+            {
+                "action_type": "type",
+                "text": "Bonjour",
+                "window": "OnlyOffice",
+                "timestamp": (base_time + timedelta(seconds=10)).isoformat(),
+                "description": "Tape du texte"
+            }
+        ]
+        
+        # Ajouter les actions
+        for action in actions:
+            event_capture.session_manager.add_action(action)
+        
+        # Finaliser la session
+        event_capture.session_manager.force_finalize_session()
+        
+        print(f"   ✅ {len(actions)} actions ajoutées")
+    
+    # Analyser pour détecter des workflows
+    print(f"\n🔍 Analyse des sessions pour détecter des workflows...")
+    recent_sessions = event_capture.session_manager.get_recent_sessions(10)
+    event_capture.workflow_detector.analyze_sessions(recent_sessions)
+    
+    # Vérifier les workflows détectés
+    workflows = event_capture.get_workflows()
+    print(f"\n📊 Workflows détectés: {len(workflows)}")
+    
+    if workflows:
+        for workflow in workflows:
+            print(f"   - {workflow.name} ({workflow.repetitions}x, {workflow.confidence:.2%})")
+            print(f"     Étapes: {len(workflow.steps)}")
+    else:
+        print("   ❌ Aucun workflow détecté")
+        print("\n⚠️  Le test ne peut pas continuer sans workflows")
+        return
+    
+    print(f"\n📋 Phase 2: Simuler le début d'un workflow...\n")
+    
+    # Créer une nouvelle session qui commence comme le workflow
+    print("Début d'une nouvelle session...")
+    current_time = datetime.now()
+    
+    # Première action du workflow
+    action1 = {
+        "action_type": "click",
+        "position": (100, 50),
+        "window": "Desktop",
+        "timestamp": current_time.isoformat(),
+        "description": "Clic sur lanceur"
+    }
+    event_capture.session_manager.add_action(action1)
+    print(f"   ✅ Action 1: {action1['description']}")
+    
+    time.sleep(0.5)
+    
+    # Deuxième action du workflow
+    action2 = {
+        "action_type": "type",
+        "text": "office",
+        "window": "Desktop",
+        "timestamp": (current_time + timedelta(seconds=2)).isoformat(),
+        "description": "Tape 'office'"
+    }
+    event_capture.session_manager.add_action(action2)
+    print(f"   ✅ Action 2: {action2['description']}")
+    
+    print(f"\n🔍 Vérification de suggestion de workflow...\n")
+    
+    # Créer un contexte pour la suggestion
+    context = {
+        "event_capture": event_capture,
+        "embedding": np.random.rand(512),  # Mock embedding
+        "window": "Desktop",
+        "timestamp": datetime.now()
+    }
+    
+    # Chercher une suggestion
+    suggestion = suggestion_manager.find_suggestion(context)
+    
+    if suggestion:
+        print(f"✅ Suggestion trouvée !")
+        print(f"   Type: {suggestion.get('type')}")
+        
+        if suggestion.get('type') == 'workflow':
+            print(f"   Workflow: {suggestion['workflow_name']}")
+            print(f"   Étape actuelle: {suggestion['current_step']}/{suggestion['total_steps']}")
+            print(f"   Prochaine action: {suggestion['next_action']['description']}")
+            print(f"   Actions restantes: {suggestion['remaining_steps']}")
+            print(f"   Confiance: {suggestion['confidence']:.2%}")
+            
+            # Créer la suggestion dans le manager
+            suggestion_manager.create_suggestion(context)
+            
+            print(f"\n📈 Statistiques:")
+            stats = suggestion_manager.get_stats()
+            print(f"   Suggestion active: {stats['has_active_suggestion']}")
+            
+    else:
+        print(f"❌ Aucune suggestion trouvée")
+        print(f"\n🔍 Debug:")
+        print(f"   Workflows: {len(workflows)}")
+        print(f"   Session courante: {event_capture.session_manager.current_session}")
+        if event_capture.session_manager.current_session:
+            print(f"   Actions dans session: {event_capture.session_manager.current_session.action_count}")
+    
+    print(f"\n" + "="*60)
+    print(f"  ✅ TEST TERMINÉ")
+    print(f"  Suggestions créées: {len(suggestions_created)}")
+    print(f"="*60)
+
+
+if __name__ == "__main__":
+    main()