# RPA Vision V2

Système d'automatisation robotique à apprentissage progressif utilisant la vision par ordinateur et l'IA.

## Vue d'Ensemble

RPA Vision V2 observe, apprend et automatise les interactions avec les interfaces utilisateur à travers trois modes opérationnels:

- **👀 Shadow**: Observation uniquement, apprentissage des actions utilisateur
- **🤝 Assisté**: Suggestions avec validation utilisateur requise
- **🤖 Autopilot**: Exécution autonome après atteinte des seuils de confiance

## Architecture

```
geniusia2/
├── core/              # Logique centrale (orchestration, apprentissage)
│   ├── config.py      # Configuration globale
│   └── utils/         # Utilitaires (image, vision, input)
├── gui/               # Interface PyQt5
│   └── dialogs/       # Dialogues de correction et tableau de bord
├── data/              # Données persistantes
│   ├── user_profiles/ # Profils d'apprentissage (JSON)
│   ├── logs/          # Logs chiffrés AES-256
│   └── faiss_index/   # Index de mémoire visuelle
└── models/            # Modèles IA
    ├── openclip/      # Embeddings visuels
    ├── owl_v2/        # Détection UI
    └── qwen2.5_vl/    # Raisonnement visuel
```

## Installation

### Prérequis

- **Système**: Linux (Ubuntu 20.04+), macOS 11+, ou Windows 10+
- **Python**: 3.9 ou supérieur
- **RAM**: 16GB minimum (32GB recommandé)
- **GPU**: NVIDIA avec 8GB+ VRAM (optionnel mais recommandé pour meilleures performances)
- **Espace disque**: 20GB minimum

### Installation Automatique (Recommandé)

Le script d'installation configure automatiquement tout l'environnement:

```bash
# Rendre le script exécutable
chmod +x setup.sh

# Lancer l'installation
./setup.sh
```

Le script va:
1. ✅ Créer un environnement virtuel Python
2. ✅ Installer toutes les dépendances Python
3. ✅ Installer Ollama (si nécessaire)
4. ✅ Télécharger le modèle Qwen 2.5-VL
5. ✅ Créer les répertoires de données
6. ✅ Générer les clés de chiffrement
7. ✅ Configurer les modèles de vision

### Installation Manuelle

Si vous préférez installer manuellement:

1. **Créer un environnement virtuel**:
```bash
python3 -m venv venv
source venv/bin/activate  # Linux/macOS
# ou
venv\Scripts\activate  # Windows
```

2. **Installer les dépendances Python**:
```bash
pip install --upgrade pip
pip install -r requirements.txt
```

3. **Installer Ollama**:
```bash
# Linux/macOS
curl -fsSL https://ollama.com/install.sh | sh

# Windows: Télécharger depuis https://ollama.com/download
```

4. **Télécharger le modèle Qwen 2.5-VL**:
```bash
ollama pull qwen2.5-vl:7b
```

5. **Créer les répertoires**:
```bash
mkdir -p data/{user_profiles,logs,faiss_index,whitelist}
mkdir -p models
```

6. **Générer les clés de chiffrement**:
```bash
python3 -c "from cryptography.fernet import Fernet; import os; key = Fernet.generate_key(); os.makedirs('data', exist_ok=True); open('data/.encryption_key', 'wb').write(key)"
```

## Configuration

La configuration globale se trouve dans `core/config.py`:

- **Modèles**: Choix des modèles de vision et LLM
- **Seuils**: Critères de transition entre modes
- **Performance**: Latence maximale, taux de correction
- **Sécurité**: Chiffrement, liste blanche, rétention des logs

## Utilisation

### Démarrage

1. **Activer l'environnement virtuel** (si pas déjà fait):
```bash
source venv/bin/activate  # Linux/macOS
# ou
venv\Scripts\activate  # Windows
```

2. **Lancer l'application**:
```bash
python3 main.py
```

### Interface Graphique

L'interface minimale affiche:
- **Indicateur de mode**: 👀 Shadow / 🤝 Assisté / 🤖 Autopilot
- **Boutons de contrôle**: Start, Stop, Pause
- **Statut**: État actuel du système
- **Métriques**: Confiance, observations, concordance

### Raccourcis Clavier

| Raccourci | Action |
|-----------|--------|
| **Ctrl+Pause** | Arrêt d'urgence immédiat |
| **Entrée** | Valider une suggestion (mode Assisté) |
| **Échap** | Rejeter une suggestion (mode Assisté) |
| **Alt+C** | Ouvrir le dialogue de correction |
| **Ctrl+D** | Ouvrir le tableau de bord des métriques |

### Workflow Typique

1. **Mode Shadow (👀)**:
   - Lancez l'application
   - Effectuez vos tâches normalement
   - Le système observe et apprend silencieusement
   - Après ≥20 observations avec ≥95% de concordance, transition automatique proposée

2. **Mode Assisté (🤝)**:
   - Le système suggère des actions avec surlignage visuel
   - Validez avec **Entrée** ou rejetez avec **Échap**
   - Corrigez avec **Alt+C** si nécessaire
   - Après ≥20 validations avec ≥95% de concordance, passage en Autopilot proposé

3. **Mode Autopilot (🤖)**:
   - Exécution automatique des tâches apprises
   - Notifications post-action (✔️ succès / ❌ échec)
   - Retour automatique en Assisté si confiance <90%
   - Rollback possible des 3 dernières actions

### Liste Blanche

Pour des raisons de sécurité, seules les applications autorisées peuvent être automatisées:

1. **Ajouter une application**:
   - Cliquez sur "Gérer Liste Blanche" dans l'interface
   - Entrez le titre de la fenêtre (ex: "Firefox", "LibreOffice")
   - Confirmez l'ajout

2. **Retirer une application**:
   - Ouvrez le gestionnaire de liste blanche
   - Sélectionnez l'application
   - Cliquez sur "Retirer"

La liste blanche est sauvegardée dans `data/whitelist/whitelist.json`

## Sécurité

RPA Vision V2 intègre plusieurs mécanismes de sécurité:

### Chiffrement
- **Logs chiffrés**: Tous les logs sont chiffrés avec AES-256-GCM
- **Clés sécurisées**: Clés de chiffrement stockées dans `data/.encryption_key`
- **Données sensibles**: Aucune donnée sensible en clair sur disque

### Contrôle d'Accès
- **Liste blanche**: Seules les applications autorisées peuvent être automatisées
- **Validation admin**: Ajout à la liste blanche nécessite confirmation
- **Audit trail**: Toutes les modifications de liste blanche sont journalisées

### Mécanismes de Sécurité
- **Arrêt d'urgence**: Ctrl+Pause arrête immédiatement toute exécution
- **Rollback**: Annulation des 3 dernières actions en cas d'erreur
- **Failsafe**: Déplacer la souris dans le coin supérieur gauche arrête PyAutoGUI
- **Détection de dérive**: Alerte si l'UI change de manière inattendue

### Confidentialité
- **Données locales**: Toutes les données restent sur votre machine
- **Pas de télémétrie**: Aucune donnée envoyée à des serveurs externes
- **Rétention configurable**: Durée de conservation des logs paramétrable

### Bonnes Pratiques
1. Ne jamais ajouter d'applications sensibles (banque, admin système) à la liste blanche
2. Tester en mode Shadow avant de passer en Autopilot
3. Surveiller régulièrement le tableau de bord des métriques
4. Sauvegarder régulièrement `data/` pour préserver l'apprentissage

## Dépannage

### Problèmes Courants

**1. Erreur "Ollama not found"**
```bash
# Vérifier si Ollama est installé
ollama --version

# Si non installé, installer:
curl -fsSL https://ollama.com/install.sh | sh
```

**2. Erreur "Model not found"**
```bash
# Télécharger le modèle
ollama pull qwen2.5-vl:7b

# Vérifier les modèles installés
ollama list
```

**3. Erreur "Permission denied" sur setup.sh**
```bash
# Rendre le script exécutable
chmod +x setup.sh
```

**4. Latence élevée (>400ms)**
- Vérifier que le GPU est utilisé (si disponible)
- Réduire la résolution de capture dans `core/config.py`
- Utiliser un modèle plus léger (qwen2.5-vl:3b au lieu de 7b)

**5. Détection UI imprécise**
- Augmenter le seuil de confiance dans `core/config.py`
- Essayer un autre modèle de vision (OWL-v2, DINO, YOLO)
- Fournir plus d'exemples en mode Shadow

**6. Erreur "PyAutoGUI failsafe triggered"**
- La souris a été déplacée dans le coin supérieur gauche
- C'est un mécanisme de sécurité
- Relancez l'application et évitez ce coin

### Logs et Débogage

Les logs sont stockés dans `data/logs/` (chiffrés). Pour les consulter:

```python
from core.logger import Logger
from core.config import Config

config = Config()
logger = Logger(config.get_all())

# Récupérer les logs récents
logs = logger.get_logs(limit=100)
for log in logs:
    print(log)
```

### Support

Pour signaler un bug ou demander de l'aide:
1. Vérifiez les logs dans `data/logs/`
2. Consultez la documentation des modules dans `core/*/README.md`
3. Vérifiez les métriques dans le tableau de bord

## Performance

### Métriques Cibles

| Métrique | Cible | Critique |
|----------|-------|----------|
| **Latence** | <400ms | <1000ms |
| **Concordance** | ≥95% | ≥90% |
| **Taux de correction** | <3% | <10% |
| **Précision détection** | ≥90% | ≥80% |

### Optimisations

1. **GPU**: Utiliser un GPU NVIDIA pour accélérer les modèles
2. **Modèles**: Choisir des modèles adaptés à votre matériel
3. **Résolution**: Réduire la résolution de capture si nécessaire
4. **Cache**: Les embeddings sont mis en cache dans FAISS
5. **Batch**: Les opérations sont groupées quand possible

## Architecture Technique

### Composants Principaux

- **Orchestrator**: Boucle cognitive principale
- **LearningManager**: Gestion de l'apprentissage et des transitions
- **VisionUtils**: Détection d'éléments UI avec modèles vision
- **LLMManager**: Raisonnement visuel avec Qwen 2.5-VL
- **EmbeddingsManager**: Mémoire visuelle avec OpenCLIP + FAISS
- **WhitelistManager**: Contrôle d'accès aux applications
- **UIChangeDetector**: Détection de dérives d'interface
- **MetricsCollector**: Surveillance des performances
- **ReplayEngine**: Rejeu et rollback d'actions

### Flux de Données

```
Capture écran → Détection UI → Raisonnement LLM → Décision
                     ↓              ↓                ↓
                Embeddings → Mémoire FAISS → Apprentissage
                                                     ↓
                                              Exécution/Suggestion
```

## Documentation Détaillée

- **Exigences**: `.kiro/specs/rpa-vision-v2/requirements.md`
- **Design**: `.kiro/specs/rpa-vision-v2/design.md`
- **Tâches**: `.kiro/specs/rpa-vision-v2/tasks.md`
- **Modules**:
  - `core/ORCHESTRATOR_README.md`
  - `core/LEARNING_MANAGER_README.md`
  - `core/WHITELIST_MANAGER_README.md`
  - `core/UI_CHANGE_DETECTOR_README.md`
  - `core/utils/VISION_UTILS_README.md`
  - `gui/README.md`
  - `gui/dialogs/README.md`

## Contribution

Ce projet est en développement actif. Les contributions sont les bienvenues:
1. Fork le projet
2. Créer une branche feature
3. Commiter les changements
4. Pousser vers la branche
5. Ouvrir une Pull Request

## Licence

Propriétaire - Amina 2025

## Remerciements

- **OpenCLIP**: Embeddings visuels
- **Ollama**: Infrastructure LLM locale
- **Qwen 2.5-VL**: Modèle de vision-langage
- **FAISS**: Recherche de similarité vectorielle
- **PyQt5**: Interface graphique
- **PyAutoGUI**: Contrôle des entrées
