Initial commit

This commit is contained in:
Dom
2026-03-05 00:20:25 +01:00
commit dcd4de9945
1954 changed files with 669380 additions and 0 deletions

View File

@@ -0,0 +1,257 @@
# Orchestrateur - Boucle Cognitive RPA Vision V2
## Vue d'ensemble
L'orchestrateur est le composant central de RPA Vision V2 qui implémente la boucle cognitive principale suivant le paradigme **Observer → Réfléchir → Agir → Apprendre**.
## Architecture
```
┌─────────────────────────────────────────────────┐
│ BOUCLE COGNITIVE PRINCIPALE │
│ │
│ 1. OBSERVER │
│ ├─ Capturer l'écran (capture_screen) │
│ └─ Détecter fenêtre active │
│ │
│ 2. RÉFLÉCHIR │
│ ├─ Détecter éléments UI (VisionUtils) │
│ └─ Raisonner sur l'action (LLMManager) │
│ │
│ 3. AGIR │
│ ├─ Mode Shadow: Observer uniquement │
│ ├─ Mode Assisté: Suggérer + Valider │
│ └─ Mode Autopilot: Exécuter │
│ │
│ 4. APPRENDRE │
│ └─ Mettre à jour LearningManager │
└─────────────────────────────────────────────────┘
```
## Composants Intégrés
- **LearningManager**: Gestion de l'apprentissage et transitions de mode
- **VisionUtils**: Détection d'éléments UI avec OWL-v2/DINO/YOLO
- **LLMManager**: Raisonnement visuel avec Qwen 2.5-VL
- **Logger**: Journalisation chiffrée de toutes les actions
- **GUI**: Interface utilisateur (optionnel)
## Modes Opérationnels
### Mode Shadow (👀)
- Observe les actions utilisateur sans exécuter
- Enregistre les observations pour apprentissage
- Construit la mémoire visuelle
### Mode Assisté (🤝)
- Suggère des actions basées sur l'apprentissage
- Attend validation utilisateur (Entrée/Échap/Alt+C)
- Apprend des corrections
### Mode Autopilot (🤖)
- Exécute automatiquement les actions
- Vérifie la liste blanche avant exécution
- Rétrograde si confiance < 90%
## Sécurité
### Liste Blanche
- Vérifie que la fenêtre est autorisée avant toute action
- Bloque et journalise les violations
- Configurable dynamiquement
### Arrêt d'Urgence
- Ctrl+Pause (ou Ctrl+C) arrête immédiatement
- Journalise l'événement de sécurité
- Retour au mode Assisté
### Journalisation
- Toutes les actions sont loggées avec chiffrement AES-256
- Inclut: fenêtre, action, confiance, résultat
- Traçabilité complète pour audit
## Métriques de Performance
L'orchestrateur suit:
- **total_cycles**: Nombre de cycles de la boucle cognitive
- **avg_latency_ms**: Latence moyenne (cible: <400ms)
- **detections_count**: Nombre d'éléments détectés
- **actions_executed**: Actions exécutées en mode Autopilot
- **actions_suggested**: Actions suggérées en mode Assisté
## Utilisation
### Initialisation
```python
from geniusia2.core.orchestrator import Orchestrator
from geniusia2.core.learning_manager import LearningManager
from geniusia2.core.utils.vision_utils import VisionUtils
from geniusia2.core.llm_manager import LLMManager
from geniusia2.core.logger import Logger
from geniusia2.core.embeddings_manager import EmbeddingsManager
from geniusia2.core.config import get_config
# Initialiser les composants
config = get_config()
logger = Logger()
embeddings_manager = EmbeddingsManager()
learning_manager = LearningManager(embeddings_manager, logger, config)
vision_utils = VisionUtils(config)
llm_manager = LLMManager(logger=logger)
# Créer l'orchestrateur
orchestrator = Orchestrator(
learning_manager=learning_manager,
vision_utils=vision_utils,
llm_manager=llm_manager,
logger=logger,
gui=None # Ou votre instance GUI
)
```
### Démarrage
```python
# Configurer la liste blanche
orchestrator.add_to_whitelist("Dolibarr*")
orchestrator.add_to_whitelist("Firefox*")
# Définir l'intention actuelle
learning_manager.set_current_context({"intent": "cliquer sur valider"})
# Démarrer la boucle cognitive (dans un thread séparé)
import threading
cognitive_thread = threading.Thread(target=orchestrator.run)
cognitive_thread.start()
# Arrêter proprement
orchestrator.stop()
cognitive_thread.join()
```
### Gestion de la Liste Blanche
```python
# Ajouter une fenêtre
orchestrator.add_to_whitelist("MonApplication*")
# Retirer une fenêtre
orchestrator.remove_from_whitelist("MonApplication*")
# Obtenir la liste
whitelist = orchestrator.get_whitelist()
# Activer/désactiver l'application
orchestrator.set_whitelist_enforcement(True)
```
### Contrôle de la Boucle
```python
# Mettre en pause
orchestrator.pause()
# Reprendre
orchestrator.resume()
# Arrêter
orchestrator.stop()
```
### Consultation des Métriques
```python
# Obtenir les métriques
metrics = orchestrator.get_metrics()
print(f"Cycles: {metrics['total_cycles']}")
print(f"Latence moyenne: {metrics['avg_latency_ms']:.2f}ms")
# Obtenir le statut complet
status = orchestrator.get_status()
print(f"Mode: {status['mode']}")
print(f"Fenêtre actuelle: {status['current_window']}")
```
## Flux de Décision
```
Capture Contexte
Détection UI (Vision)
Raisonnement (LLM)
Calcul Confiance
┌─────────────────┐
│ Mode actuel? │
└─────────────────┘
┌──┴──┬──────┬──────┐
│ │ │ │
Shadow Assist Auto │
│ │ │ │
↓ ↓ ↓ ↓
Observer Suggérer Vérifier Exécuter
+ Liste
Valider Blanche
↓ ↓
Apprendre Apprendre
```
## Gestion des Erreurs
### Échec de Capture
- Log l'erreur
- Continue la boucle
- Réessaie au cycle suivant
### Échec de Détection
- Essaie les modèles de fallback (OWL-v2 → DINO → YOLO)
- Si tous échouent, log et continue
### Échec LLM
- Fallback vers sélection basée vision pure
- Continue avec confiance réduite
### Violation Liste Blanche
- Bloque l'action immédiatement
- Log événement de sécurité
- Notifie l'utilisateur
## Exigences Satisfaites
✓ 1.1, 1.2 - Capture d'écran et détection fenêtre
✓ 2.1, 2.2, 2.3, 2.4, 2.5 - Modes et suggestions
✓ 3.2, 3.3 - Exécution automatique et arrêt d'urgence
✓ 5.3, 5.4 - Liste blanche et sécurité
✓ 6.2, 6.3 - Notifications et alertes
## Tests
Exécuter les tests basiques:
```bash
python3 test_orchestrator_simple.py
```
Pour tester avec tous les composants (nécessite PyTorch, etc.):
```bash
python3 -m geniusia2.core.orchestrator
```
## Notes d'Implémentation
- La boucle cognitive s'exécute dans un thread séparé
- Latence cible: <400ms par cycle
- Utilise des événements threading pour arrêt/pause propre
- Toutes les actions sont journalisées avec chiffrement
- Support multi-plateforme (Linux, Windows, macOS)
## Prochaines Étapes
1. Implémenter `input_utils.py` pour exécution réelle des actions
2. Implémenter `replay_async.py` pour rollback
3. Intégrer avec la GUI PyQt5
4. Ajouter le système de détection de changements UI
5. Implémenter les métriques avancées