# 🔄 Refonte : Détection de Workflows Complets

## 🎯 Objectif

Transformer le système d'un détecteur de **micro-patterns** (3 clics identiques) en un détecteur de **macro-workflows** (séquences d'actions répétées).

## ❌ Problème Actuel

### Ce qui est implémenté
```python
# EventCapture détecte :
Clic A, Clic A, Clic A → Pattern détecté ✅
```

**Problème** : Personne ne clique 3 fois sur le même bouton dans la vraie vie !

### Ce qu'il faut
```python
# Détecter des workflows :
Jour 1: [Ouvre App → Clic Menu → Type Texte → Sauvegarde]
Jour 2: [Ouvre App → Clic Menu → Type Texte → Sauvegarde]
Jour 3: [Ouvre App → Clic Menu → Type Texte → Sauvegarde]
→ Workflow détecté ✅
```

## ✅ Solution : Workflow Pattern Detector

### 1. Nouvelle Architecture

```
EventCapture (capture toutes les actions)
    ↓
WorkflowBuffer (garde les N dernières actions)
    ↓
WorkflowDetector (détecte les séquences répétées)
    ↓
WorkflowManager (crée et gère les workflows)
    ↓
SuggestionManager (suggère le workflow suivant)
```

### 2. Algorithme de Détection

#### Étape 1 : Segmentation Temporelle
```python
# Diviser les actions en "sessions"
# Une session = actions dans une fenêtre de temps (ex: 5 minutes)

Session 1: [Action1, Action2, Action3, Action4]  # 10h00-10h05
Session 2: [Action5, Action6, Action7]           # 10h30-10h35
Session 3: [Action8, Action9, Action10, Action11] # 11h00-11h05
```

#### Étape 2 : Comparaison de Séquences
```python
# Comparer les sessions pour trouver des similarités

def compare_sessions(session1, session2):
    # Utiliser la distance de Levenshtein sur les embeddings
    # Ou DTW (Dynamic Time Warping)
    # Ou similarité cosinus entre séquences
    
    similarity = calculate_sequence_similarity(session1, session2)
    return similarity > threshold  # ex: 0.75
```

#### Étape 3 : Détection de Répétition
```python
# Si 3 sessions similaires → Workflow détecté

if count_similar_sessions() >= 3:
    workflow = create_workflow(sessions)
    save_workflow(workflow)
    notify_user("Workflow détecté !")
```

### 3. Structure de Données

#### Workflow
```python
@dataclass
class Workflow:
    workflow_id: str
    name: str  # "Ouvrir OnlyOffice et créer document"
    steps: List[WorkflowStep]
    repetitions: int  # Nombre de fois observé
    confidence: float
    last_seen: datetime
    
@dataclass
class WorkflowStep:
    step_id: int
    action_type: str  # "click", "type", "scroll"
    target_description: str  # "Bouton Nouveau Document"
    screenshot: np.ndarray
    embedding: np.ndarray
    position: Tuple[int, int]
    window: str
```

### 4. Détection en Temps Réel

```python
class WorkflowDetector:
    def __init__(self):
        self.action_buffer = deque(maxlen=100)  # 100 dernières actions
        self.sessions = []
        self.known_workflows = []
    
    def on_action(self, action):
        # Ajouter l'action au buffer
        self.action_buffer.append(action)
        
        # Vérifier si on doit créer une nouvelle session
        if self.should_start_new_session(action):
            self.finalize_current_session()
            self.start_new_session()
        
        # Ajouter l'action à la session courante
        self.current_session.append(action)
        
        # Vérifier si on détecte un workflow
        if len(self.sessions) >= 3:
            workflow = self.detect_workflow()
            if workflow:
                self.on_workflow_detected(workflow)
    
    def should_start_new_session(self, action):
        # Nouvelle session si :
        # - Plus de 5 minutes depuis la dernière action
        # - Changement de fenêtre majeur
        # - Action de "fin" (fermeture, sauvegarde)
        
        if not self.current_session:
            return True
        
        last_action = self.current_session[-1]
        time_gap = action.timestamp - last_action.timestamp
        
        return (
            time_gap > timedelta(minutes=5) or
            action.window != last_action.window or
            action.action_type in ["close", "save"]
        )
    
    def detect_workflow(self):
        # Comparer les 3 dernières sessions
        recent_sessions = self.sessions[-3:]
        
        # Calculer la similarité entre elles
        sim_01 = self.compare_sessions(recent_sessions[0], recent_sessions[1])
        sim_12 = self.compare_sessions(recent_sessions[1], recent_sessions[2])
        sim_02 = self.compare_sessions(recent_sessions[0], recent_sessions[2])
        
        avg_similarity = (sim_01 + sim_12 + sim_02) / 3
        
        if avg_similarity > 0.75:
            # Créer le workflow
            return self.create_workflow_from_sessions(recent_sessions)
        
        return None
    
    def compare_sessions(self, session1, session2):
        # Utiliser DTW (Dynamic Time Warping) pour comparer
        # les séquences d'embeddings
        
        embeddings1 = [action.embedding for action in session1]
        embeddings2 = [action.embedding for action in session2]
        
        distance = dtw_distance(embeddings1, embeddings2)
        similarity = 1 / (1 + distance)
        
        return similarity
```

### 5. Suggestion de Workflow

```python
class WorkflowSuggestionManager:
    def check_for_workflow_suggestion(self, current_actions):
        # Vérifier si les actions actuelles correspondent
        # au début d'un workflow connu
        
        for workflow in self.known_workflows:
            match_score = self.match_workflow_start(
                current_actions,
                workflow.steps
            )
            
            if match_score > 0.75:
                # On est probablement au début du workflow !
                return {
                    "workflow": workflow,
                    "confidence": match_score,
                    "next_steps": workflow.steps[len(current_actions):]
                }
        
        return None
    
    def match_workflow_start(self, current_actions, workflow_steps):
        # Comparer les N premières actions avec le début du workflow
        
        if len(current_actions) > len(workflow_steps):
            return 0.0
        
        similarities = []
        for i, action in enumerate(current_actions):
            step = workflow_steps[i]
            sim = cosine_similarity(action.embedding, step.embedding)
            similarities.append(sim)
        
        return np.mean(similarities)
```

## 📊 Exemple Concret

### Scénario : OnlyOffice

```python
# Jour 1 - 10h00
Session 1:
  1. Clic sur lanceur (embedding_1)
  2. Type "office" (embedding_2)
  3. Clic sur OnlyOffice (embedding_3)
  4. Clic "Nouveau document" (embedding_4)
  5. Type "Bonjour" (embedding_5)
  6. Clic "Fermer" (embedding_6)
  7. Clic "Non" (embedding_7)

# Jour 2 - 14h30
Session 2:
  1. Clic sur lanceur (embedding_1')  # Similaire à embedding_1
  2. Type "office" (embedding_2')
  3. Clic sur OnlyOffice (embedding_3')
  4. Clic "Nouveau document" (embedding_4')
  5. Type "Hello" (embedding_5')  # Différent mais même type d'action
  6. Clic "Fermer" (embedding_6')
  7. Clic "Non" (embedding_7')

# Jour 3 - 16h00
Session 3:
  1. Clic sur lanceur (embedding_1'')
  2. Type "office" (embedding_2'')
  3. Clic sur OnlyOffice (embedding_3'')
  4. Clic "Nouveau document" (embedding_4'')
  5. Type "Test" (embedding_5'')
  6. Clic "Fermer" (embedding_6'')
  7. Clic "Non" (embedding_7'')

# Détection
compare_sessions(Session1, Session2) = 0.89
compare_sessions(Session2, Session3) = 0.91
compare_sessions(Session1, Session3) = 0.87

avg_similarity = 0.89 > 0.75 ✅

→ Workflow "Ouvrir OnlyOffice et créer document" détecté !
```

### Jour 4 - Suggestion

```python
# L'utilisateur commence
Action 1: Clic sur lanceur
Action 2: Type "office"

# Le système détecte
match_score = match_workflow_start([Action1, Action2], Workflow.steps)
match_score = 0.92 > 0.75 ✅

# Suggestion !
"Je peux continuer ce workflow pour toi ?"
[Oui] [Non] [Corriger]
```

## 🔧 Implémentation

### Fichiers à Créer

1. `geniusia2/core/workflow_detector.py` - Détection de workflows
2. `geniusia2/core/workflow_manager.py` - Gestion des workflows
3. `geniusia2/core/session_manager.py` - Segmentation en sessions

### Fichiers à Modifier

1. `geniusia2/core/event_capture.py` - Intégrer WorkflowDetector
2. `geniusia2/core/orchestrator.py` - Utiliser workflows au lieu de patterns
3. `geniusia2/core/suggestion_manager.py` - Suggérer workflows complets

## 📈 Avantages

### Avant (Micro-Patterns)
- ❌ Détecte seulement les clics répétés
- ❌ Inutilisable en pratique
- ❌ Ne correspond pas à l'usage réel

### Après (Macro-Workflows)
- ✅ Détecte les workflows complets
- ✅ Utilisable en pratique
- ✅ Correspond à l'usage réel
- ✅ Vrai RPA Vision !

## 🎯 Prochaines Étapes

1. **Implémenter WorkflowDetector** (3-4h)
2. **Implémenter SessionManager** (2h)
3. **Modifier EventCapture** (1h)
4. **Tester avec ton workflow OnlyOffice** (1h)
5. **Ajuster les seuils** (1h)

**Total** : ~8-10 heures de développement

## 💡 Note Importante

C'est un **changement majeur** mais **nécessaire** pour que le système soit vraiment utilisable !

Le système actuel est un MVP qui ne fonctionne que pour des cas d'usage artificiels.

Avec cette refonte, on aura un **vrai RPA Vision** qui apprend des workflows réels ! 🚀

---

**Veux-tu qu'on commence l'implémentation ?** 💪