Geniusia_v2/docs/implementation/MODE_ASSISTE_CONCEPTION.md

🤝 Mode Assisté - Conception

🎯 Objectif

Intégrer le système de rejeu dans l'Orchestrator pour fournir des suggestions en temps réel basées sur les tâches apprises.

🔄 Flux du Mode Assisté

1. Utilisateur effectue une action
   ↓
2. EventCapture détecte l'action
   ↓
3. Orchestrator capture le contexte (screenshot, fenêtre)
   ↓
4. Recherche de tâches similaires dans FAISS
   ↓
5. Si correspondance trouvée (similarité > 0.75)
   ↓
6. Afficher suggestion visuelle
   ↓
7. Attendre validation utilisateur
   ├─ Entrée → Exécuter l'action suggérée
   ├─ Échap → Ignorer
   └─ Alt+C → Corriger
   ↓
8. Mettre à jour les scores de confiance

🏗️ Architecture

Composants à Modifier

1. Orchestrator (orchestrator.py)

   • Ajouter TaskReplayEngine
   • Ajouter méthode _suggest_next_action()
   • Ajouter méthode _handle_suggestion_response()

2. GUI (minimal_gui.py)

   • Ajouter overlay de suggestion
   • Ajouter gestion des touches (Entrée/Échap/Alt+C)

3. LearningManager (learning_manager.py)

   • Ajouter méthode find_similar_tasks()
   • Améliorer suggest_action()

Nouveaux Composants

1. SuggestionManager (nouveau)
   • Gère les suggestions en temps réel
   • Calcule les scores de confiance
   • Gère les timeouts

📝 Implémentation

Étape 1 : Intégrer TaskReplayEngine dans Orchestrator

from .task_replay import TaskReplayEngine

class Orchestrator:
    def __init__(self, ...):
        # ... code existant ...
        
        # Moteur de rejeu pour suggestions
        self.replay_engine = TaskReplayEngine(
            learning_manager,
            embeddings_manager,
            vision_utils,
            input_utils,
            logger,
            config
        )

Étape 2 : Ajouter la Détection de Contexte

def _capture_context(self) -> Dict[str, Any]:
    """Capture le contexte actuel pour suggestions."""
    screenshot = capture_screen()
    window = get_active_window()
    
    # Générer embedding du contexte
    embedding = self.vision_analyzer.generate_embedding(screenshot)
    
    return {
        "screenshot": screenshot,
        "window": window,
        "embedding": embedding,
        "timestamp": datetime.now()
    }

Étape 3 : Recherche de Tâches Similaires

def _find_similar_tasks(self, context: Dict[str, Any]) -> List[Dict]:
    """Recherche les tâches similaires au contexte actuel."""
    embedding = context["embedding"]
    
    # Rechercher dans FAISS
    results = self.learning_manager.embeddings_manager.search_similar(
        embedding,
        k=3
    )
    
    # Filtrer par seuil de similarité
    similar_tasks = [
        r for r in results 
        if r["similarity"] >= 0.75
    ]
    
    return similar_tasks

Étape 4 : Générer et Afficher Suggestion

def _suggest_next_action(self, context: Dict[str, Any]):
    """Génère et affiche une suggestion d'action."""
    # Rechercher tâches similaires
    similar_tasks = self._find_similar_tasks(context)
    
    if not similar_tasks:
        return
    
    # Prendre la meilleure correspondance
    best_match = similar_tasks[0]
    task_id = best_match["metadata"]["task_id"]
    
    # Charger la tâche
    task = self.learning_manager.load_task(task_id)
    
    if not task:
        return
    
    # Obtenir la prochaine action suggérée
    suggestion = self.learning_manager.suggest_action(context)
    
    if suggestion and suggestion["confidence"] >= 0.75:
        # Afficher dans la GUI
        if self.gui:
            self.gui.show_suggestion(suggestion)

Étape 5 : Gestion des Réponses

def _handle_suggestion_response(self, response: str, suggestion: Dict):
    """Gère la réponse de l'utilisateur à une suggestion."""
    if response == "accept":
        # Exécuter l'action suggérée
        self._execute_suggested_action(suggestion)
        
        # Mettre à jour la confiance (positif)
        self.learning_manager.confirm_action({
            "type": "accept",
            "task_id": suggestion["task_id"]
        })
    
    elif response == "reject":
        # Ne rien faire
        
        # Mettre à jour la confiance (négatif)
        self.learning_manager.confirm_action({
            "type": "reject",
            "task_id": suggestion["task_id"]
        })
    
    elif response == "correct":
        # Ouvrir dialogue de correction
        if self.gui:
            self.gui.show_correction_dialog(suggestion)

🎨 Interface Utilisateur

Overlay de Suggestion

┌─────────────────────────────────────┐
│  💡 Suggestion                      │
│                                     │
│  Action : Clic sur "Enregistrer"   │
│  Confiance : 89%                    │
│                                     │
│  [Entrée] Accepter                  │
│  [Échap] Refuser                    │
│  [Alt+C] Corriger                   │
└─────────────────────────────────────┘

Touches Clavier

Touche	Action
Entrée	Accepter et exécuter
Échap	Refuser
Alt+C	Ouvrir dialogue de correction

📊 Métriques

Scores de Confiance

confidence = (
    0.6 * vision_similarity +  # Similarité visuelle CLIP
    0.3 * llm_score +          # Score LLM
    0.1 * historical_success   # Taux de succès historique
)

Seuils

• Afficher suggestion : confidence >= 0.75
• Exécution auto : confidence >= 0.95 (Mode Autopilot)
• Rollback : confidence < 0.85 (retour en Mode Assisté)

🔄 Transitions de Mode

Shadow (observation)
  ↓ (5+ observations)
Assisté (suggestions)
  ↓ (20+ obs + 95% concordance)
Autopilot (automatique)
  ↓ (confiance < 85%)
Assisté (retour)

🧪 Tests

Test 1 : Suggestion Simple

1. Apprendre une tâche (3x clic sur "Enregistrer")
2. Refaire l'action une fois
3. Vérifier qu'une suggestion apparaît

Test 2 : Acceptation

1. Suggestion affichée
2. Appuyer sur Entrée
3. Vérifier que l'action est exécutée

Test 3 : Refus

1. Suggestion affichée
2. Appuyer sur Échap
3. Vérifier que rien n'est exécuté

📝 Prochaines Étapes

1. ✅ Créer SuggestionManager
2. ✅ Modifier Orchestrator
3. ✅ Ajouter overlay dans GUI
4. ✅ Implémenter gestion des touches
5. ✅ Tester le flux complet

🎯 Résultat Attendu

Un système qui :

• Observe tes actions
• Reconnaît les patterns
• Suggère l'action suivante
• Apprend de tes choix
• S'améliore avec le temps

Le Mode Assisté sera fonctionnel ! 🚀