Initial commit

docs/implementation/MODE_ASSISTE_CONCEPTION.md

@@ -0,0 +1,269 @@
+# 🤝 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
+
+```python
+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
+
+```python
+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
+
+```python
+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
+
+```python
+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
+
+```python
+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
+
+```python
+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 ! 🚀**