# Plan d'Implémentation

- [x] 1. Configurer la structure du projet et les dépendances
  - Créer la structure de répertoires /AI/amina/geniusia2/ avec core/, gui/, data/, models/
  - Créer requirements.txt avec PyTorch, Transformers, OpenCLIP, FAISS, PyQt5, cryptography, ollama
  - Créer core/config.py avec configuration globale (modèles, seuils, performance, sécurité)
  - Initialiser les répertoires data/ pour user_profiles/, logs/, faiss_index/
  - _Exigences : 1.1, 1.2, 1.3, 1.4, 1.5, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 3.1, 3.2, 3.3, 3.4, 3.5, 3.6, 3.7, 4.1, 4.2, 4.3, 4.4, 4.5, 4.6, 5.1, 5.2, 5.3, 5.4, 5.5, 5.6, 5.7, 5.8, 6.1, 6.2, 6.3, 6.4, 6.5, 6.6_

- [x] 2. Implémenter les modèles de données et utilitaires de base
  - [x] 2.1 Créer les dataclasses TaskProfile, Action, Detection dans core/models.py
    - Implémenter TaskProfile avec sérialisation JSON
    - Implémenter Action avec conversion dict
    - Implémenter Detection avec métadonnées modèle
    - _Exigences : 1.2, 1.4, 2.6, 4.1, 4.2, 4.3, 5.2, 6.1_
  
  - [x] 2.2 Implémenter core/utils/image_utils.py pour capture d'écran et ROI
    - Écrire fonction capture_screen() pour capturer l'écran complet
    - Écrire fonction get_active_window() pour obtenir le titre de fenêtre active
    - Écrire fonction extract_roi(frame, bbox) pour extraire région d'intérêt
    - Écrire fonction draw_bbox(frame, bbox, label) pour dessiner bounding box
    - _Exigences : 1.1, 1.2, 2.1, 4.1_

- [x] 3. Implémenter le système de journalisation chiffrée
  - [x] 3.1 Créer core/logger.py avec chiffrement AES-256
    - Implémenter classe Logger avec initialisation de clés AES
    - Écrire méthode encrypt_entry(data) pour chiffrer les entrées
    - Écrire méthode decrypt_entry(encrypted_data) pour déchiffrer
    - Écrire méthode log_action(action_data) pour enregistrer actions
    - Écrire méthode log_correction(correction_data) pour enregistrer corrections
    - Écrire méthode log_mode_transition(task_id, from_mode, to_mode, reason)
    - Écrire méthode get_logs(task_id, start_time, end_time) pour interroger logs
    - _Exigences : 1.2, 1.3, 2.3, 2.4, 2.5, 2.6, 3.6, 4.1, 5.1, 5.2, 5.4, 6.2_

- [x] 4. Implémenter le gestionnaire d'embeddings avec OpenCLIP et FAISS
  - [x] 4.1 Créer core/embeddings_manager.py
    - Implémenter classe EmbeddingsManager avec chargement OpenCLIP
    - Écrire méthode load_openclip(model_path) pour charger le modèle
    - Écrire méthode load_or_create_index(index_path) pour FAISS
    - Écrire méthode encode_image(image) pour générer embeddings 512-d
    - Écrire méthode add_to_index(embedding, metadata) pour stocker
    - Écrire méthode search_similar(query_embedding, k) pour recherche similarité
    - Écrire méthode rebuild_index() pour reconstruire l'index
    - Écrire méthode get_embedding_similarity(emb1, emb2) pour similarité cosinus
    - _Exigences : 1.4, 2.6, 4.2, 4.3, 6.5_

- [x] 5. Implémenter les utilitaires de vision pour détection UI
  - [x] 5.1 Créer core/utils/vision_utils.py avec interfaces modèles vision
    - Implémenter classe VisionUtils avec chargement modèles (OWL-v2, DINO, YOLO)
    - Écrire méthode detect_with_owlv2(prompt, frame) pour détection OWL-v2
    - Écrire méthode detect_with_dino(prompt, frame) pour Grounding DINO
    - Écrire méthode detect_with_yolo(prompt, frame) pour YOLO-World
    - Écrire méthode select_best_detection(detections, context) pour sélection
    - Implémenter gestion d'erreurs avec fallback entre modèles
    - _Exigences : 1.1, 2.1, 4.1_

- [x] 6. Implémenter le gestionnaire LLM pour raisonnement visuel
  - [x] 6.1 Créer core/llm_manager.py avec interface Ollama
    - Implémenter classe LLMManager avec connexion Ollama
    - Écrire méthode reason_about_detections(detections, context, intent)
    - Écrire méthode generate_with_vision(prompt, images) pour génération multi-modale
    - Écrire méthode score_action_relevance(action, intent) pour score confiance
    - Écrire méthode parse_llm_response(response) pour parser réponses
    - Implémenter gestion d'erreurs avec fallback vision pure
    - _Exigences : 2.1, 4.6_

- [x] 7. Implémenter le gestionnaire d'apprentissage
  - [x] 7.1 Créer core/learning_manager.py
    - Implémenter classe LearningManager avec initialisation mode shadow
    - Écrire méthode observe(action) pour enregistrer observations en mode Shadow
    - Écrire méthode suggest_action(context) pour générer suggestions en mode Assisté
    - Écrire méthode confirm_action(feedback) pour traiter validation/correction
    - Écrire méthode calculate_confidence(vision_conf, llm_score, task_id) avec formule 0.6/0.3/0.1
    - Écrire méthode evaluate_task(task_id) pour calculer concordance
    - Écrire méthode should_transition_to_auto(task_id) pour vérifier critères (≥20 obs, ≥95% concordance)
    - Écrire méthode rollback_if_low_confidence(task_id) pour rétrograder si <90%
    - Écrire méthode get_current_intent() pour obtenir intention actuelle
    - Écrire méthode record_execution(decision) pour enregistrer exécution
    - Implémenter gestion des seuils dynamiques adaptatifs
    - _Exigences : 1.2, 1.4, 2.6, 3.1, 3.6, 4.1, 4.2, 4.4, 4.5, 4.6, 6.1, 6.4, 6.6_

- [x] 8. Implémenter l'orchestrateur (boucle cognitive)
  - [x] 8.1 Créer core/orchestrator.py
    - Implémenter classe Orchestrator avec initialisation composants
    - Écrire méthode run() pour boucle cognitive principale
    - Écrire méthode capture_context() pour capture écran et fenêtre
    - Écrire méthode detect_elements(frame, intent) pour détection UI
    - Écrire méthode reason_about_action(detections, context) pour décision LLM
    - Écrire méthode execute_or_suggest(decision) pour exécution selon mode
    - Écrire méthode execute_action(decision) pour exécution réelle
    - Écrire méthode learn_from_feedback(feedback) pour mise à jour apprentissage
    - Implémenter vérification liste blanche avant exécution
    - Implémenter gestion arrêt d'urgence Ctrl+Pause
    - _Exigences : 1.1, 1.2, 2.1, 2.2, 2.3, 2.4, 2.5, 3.2, 3.3, 5.3, 5.4, 6.2, 6.3_

- [x] 9. Implémenter les utilitaires d'entrée pour actions UI
  - [x] 9.1 Créer core/utils/input_utils.py
    - Implémenter classe InputUtils avec support AZERTY
    - Écrire méthode click(x, y) pour clic souris
    - Écrire méthode type_text(text) pour saisie texte
    - Écrire méthode scroll(direction, amount) pour défilement
    - Écrire méthode wait(duration) pour attente
    - Écrire méthode get_inverse_action(action) pour rollback
    - _Exigences : 2.3, 3.2, 5.6_

- [x] 10. Implémenter le moteur de rejeu d'actions
  - [x] 10.1 Créer core/replay_async.py
    - Implémenter classe ReplayEngine pour rejeu asynchrone
    - Écrire méthode replay_sequence(action_sequence) pour rejouer séquence
    - Écrire méthode rollback_last_n(n) pour annuler n dernières actions
    - Écrire méthode execute_inverse_actions(actions) pour rollback
    - Implémenter gestion d'erreurs avec notification échec rollback
    - _Exigences : 5.5, 5.6_

- [x] 11. Implémenter l'interface GUI minimale
  - [x] 11.1 Créer gui/minimal_gui.py avec PyQt5
    - Implémenter classe MinimalGUI héritant QMainWindow
    - Créer interface avec indicateurs de mode (👀/🤝/🤖)
    - Créer boutons Start/Stop/Pause
    - Écrire méthode update_mode_indicator(mode) pour mise à jour icône
    - Écrire méthode show_notification(message, type) pour notifications
    - Implémenter setup_shortcuts() pour raccourcis clavier
    - _Exigences : 1.5, 2.7, 3.7_
  
  - [x] 11.2 Créer superposition de suggestion
    - Implémenter classe SuggestionOverlay pour affichage suggestions
    - Écrire méthode show_suggestion(decision) pour afficher avec surlignage
    - Écrire méthode wait_for_feedback() pour attendre Entrée/Échap/Alt+C
    - Implémenter surlignage visuel des éléments UI suggérés
    - _Exigences : 2.1, 2.2, 2.3, 2.4, 2.5_

- [x] 12. Implémenter les dialogues de correction et notifications
  - [x] 12.1 Créer gui/dialogs/correction_dialog.py
    - Implémenter classe CorrectionDialog pour corrections utilisateur
    - Créer interface permettant sélection élément correct
    - Écrire méthode get_corrected_element() pour obtenir correction
    - _Exigences : 2.5, 2.6_
  
  - [x] 12.2 Implémenter système de notifications post-action
    - Créer classe PostActionNotification pour succès/échec
    - Implémenter affichage ✔️/❌ avec timeout 5 secondes
    - Écrire méthode allow_corrective_feedback() pour retour correctif
    - _Exigences : 3.4, 3.5, 3.6_
  
  - [x] 12.3 Implémenter notifications de transition et alertes
    - Créer notifications pour proposition passage Autopilot
    - Créer notifications pour baisse confiance et retour Assisté
    - Créer alertes pour violations liste blanche
    - Créer alertes pour changements UI détectés
    - _Exigences : 3.1, 4.5, 5.4, 6.2, 6.3, 6.5_

- [x] 13. Implémenter le tableau de bord résumé
  - [x] 13.1 Créer gui/dialogs/summary_dashboard.py
    - Implémenter classe SummaryDashboard avec QTableWidget
    - Créer tableau avec colonnes : Tâche, Mode, Confiance, Observations, Concordance, Corrections, Dernière exécution
    - Écrire méthode update_metrics(task_id, metrics) pour mise à jour temps réel
    - Implémenter filtrage et recherche de tâches
    - Implémenter visualisation tendances confiance
    - Implémenter fonctionnalité export CSV/JSON
    - _Exigences : 5.7, 5.8_

- [x] 14. Implémenter la gestion de la liste blanche
  - [x] 14.1 Créer module de gestion liste blanche
    - Implémenter classe WhitelistManager dans core/
    - Écrire méthode is_window_allowed(window_title) pour vérification
    - Écrire méthode add_to_whitelist(window_title) avec confirmation admin
    - Écrire méthode load_whitelist() et save_whitelist() pour persistance
    - Intégrer vérification dans orchestrator avant exécution
    - _Exigences : 5.3, 5.4_

- [x] 15. Implémenter le système de détection de changements UI
  - [x] 15.1 Créer module de détection de dérive
    - Implémenter classe UIChangeDetector dans core/
    - Écrire méthode detect_ui_change(current_embedding, stored_embeddings) avec seuil 70%
    - Écrire méthode calculate_delta(predicted_bbox, actual_bbox) pour delta pixels
    - Écrire méthode trigger_retraining(task_id) si delta >10 pixels
    - Intégrer dans learning_manager pour surveillance continue
    - _Exigences : 4.1, 4.2, 6.5_

- [x] 16. Implémenter le système de métriques et surveillance
  - [x] 16.1 Créer module de métriques
    - Implémenter classe MetricsCollector dans core/
    - Écrire méthode track_latency(start_time, end_time) pour latence <400ms
    - Écrire méthode track_concordance(task_id, success) pour taux concordance
    - Écrire méthode track_correction_rate(task_id) pour taux <3%
    - Écrire méthode check_performance_thresholds() pour alertes
    - Intégrer dans orchestrator et learning_manager
    - _Exigences : Critères globaux 1, 3, 4_

- [x] 17. Intégrer tous les composants et créer point d'entrée
  - [x] 17.1 Créer main.py
    - Initialiser configuration depuis config.py
    - Instancier tous les gestionnaires (logger, embeddings, learning, vision, llm)
    - Instancier orchestrator avec tous les composants
    - Instancier GUI et connecter signaux/slots
    - Lancer boucle cognitive dans thread séparé
    - Lancer application PyQt5
    - _Exigences : Toutes_
  
  - [x] 17.2 Implémenter gestion gracieuse d'arrêt
    - Écrire gestionnaire signal Ctrl+C pour arrêt propre
    - Sauvegarder état apprentissage avant fermeture
    - Fermer connexions (Ollama, FAISS)
    - Finaliser logs
    - _Exigences : 3.3, 5.1, 5.2_

- [x] 18. Créer scripts d'installation et configuration
  - [x] 18.1 Créer setup.sh pour installation
    - Script pour installer Ollama
    - Script pour télécharger modèle Qwen 2.5-VL via Ollama
    - Script pour télécharger modèles vision (OWL-v2, DINO)
    - Script pour installer dépendances Python
    - Script pour initialiser répertoires data/
    - Script pour générer clés chiffrement initiales
    - _Exigences : Toutes_
  
  - [x] 18.2 Créer documentation utilisateur
    - Rédiger README.md avec instructions installation
    - Rédiger guide démarrage rapide
    - Rédiger documentation configuration liste blanche
    - Rédiger documentation raccourcis clavier
    - _Exigences : Toutes_
