Geniusia_v2/.kiro/specs/rpa-vision-v2/tasks.md

Plan d'Implémentation

• 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

• 2. Implémenter les modèles de données et utilitaires de base

  • 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

  • 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

• 3. Implémenter le système de journalisation chiffrée

  • 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

• 4. Implémenter le gestionnaire d'embeddings avec OpenCLIP et FAISS

  • 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

• 5. Implémenter les utilitaires de vision pour détection UI

  • 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

• 6. Implémenter le gestionnaire LLM pour raisonnement visuel

  • 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

• 7. Implémenter le gestionnaire d'apprentissage

  • 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

• 8. Implémenter l'orchestrateur (boucle cognitive)

  • 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

• 9. Implémenter les utilitaires d'entrée pour actions UI

  • 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

• 10. Implémenter le moteur de rejeu d'actions

  • 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

• 11. Implémenter l'interface GUI minimale

  • 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

  • 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

• 12. Implémenter les dialogues de correction et notifications

  • 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

  • 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

  • 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

• 13. Implémenter le tableau de bord résumé

  • 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

• 14. Implémenter la gestion de la liste blanche

  • 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

• 15. Implémenter le système de détection de changements UI

  • 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

• 16. Implémenter le système de métriques et surveillance

  • 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

• 17. Intégrer tous les composants et créer point d'entrée

  • 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

  • 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

• 18. Créer scripts d'installation et configuration

  • 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

  • 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