Dom/rpa_vision_v3
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: replay E2E fonctionnel — 25/25 actions, 0 retries, SomEngine via serveur

Browse Source 
Validé sur PC Windows (DESKTOP-58D5CAC, 2560x1600) :
- 8 clics résolus visuellement (1 anchor_template, 1 som_text_match, 6 som_vlm)
- Score moyen 0.75, temps moyen 1.6s
- Texte tapé correctement (bonjour, test word, date, email)
- 0 retries, 2 actions non vérifiées (OK)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
Dom
2026-03-31 14:04:41 +02:00
parent 5e0b53cfd1
commit a7de6a488b
79542 changed files with 6091757 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

738
.kiro/specs/rpa-precision-enhancement/design.md Normal file
View File

@@ -0,0 +1,738 @@
# RPA Precision Enhancement - Document de Design
**Auteur**: Dom, Alice Kiro
**Date**: 15 décembre 2024
**Version**: 1.0
**Statut**: Design Initial
## 🏗️ Architecture Générale
### Vue d'Ensemble du Système
```
┌─────────────────────────────────────────────────────────────────┐
│ RPA Precision Enhancement │
├─────────────────────────────────────────────────────────────────┤
│ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │
│ │ Monitoring │ │ Performance │ │ Robustness │ │
│ │ Dashboard │ │ Optimizer │ │ Manager │ │
│ └─────────────────┘ └─────────────────┘ └─────────────────┘ │
├─────────────────────────────────────────────────────────────────┤
│ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │
│ │ Precision │ │ Adaptive │ │ Cache │ │
│ │ Metrics │ │ Calibrator │ │ Manager │ │
│ └─────────────────┘ └─────────────────┘ └─────────────────┘ │
├─────────────────────────────────────────────────────────────────┤
│ Core RPA Vision V3 │
│ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │
│ │ Target Resolver │ │ Action Executor │ │ Screen Capturer │ │
│ │ (Enhanced) │ │ (Enhanced) │ │ (Enhanced) │ │
│ └─────────────────┘ └─────────────────┘ └─────────────────┘ │
└─────────────────────────────────────────────────────────────────┘
```
### Composants Principaux
#### 1. Precision Metrics Engine
- **Responsabilité**: Collecte et analyse métriques précision temps réel
- **Interface**: `PrecisionMetricsCollector`, `MetricsAnalyzer`
- **Stockage**: TimeSeries DB (InfluxDB/Prometheus)
#### 2. Adaptive Calibrator
- **Responsabilité**: Ajustement automatique seuils et paramètres
- **Interface**: `ThresholdCalibrator`, `EnvironmentDetector`
- **Algorithmes**: ML adaptatif, A/B testing
#### 3. Robustness Manager
- **Responsabilité**: Gestion multi-environnements et récupération
- **Interface**: `EnvironmentNormalizer`, `UIChangeDetector`
- **Stratégies**: DPI normalization, fallback chains
#### 4. Performance Optimizer
- **Responsabilité**: Optimisation latence et throughput
- **Interface**: `ParallelResolver`, `CacheOptimizer`
- **Techniques**: Parallel processing, intelligent caching
#### 5. Monitoring Dashboard
- **Responsabilité**: Visualisation temps réel et alertes
- **Interface**: Web dashboard, REST API
- **Technologies**: React/TypeScript, WebSocket
## 🔧 Design Détaillé par Composant
### 1. Precision Metrics Engine
#### Architecture
```python
class PrecisionMetricsEngine:
"""
Moteur de collecte et analyse des métriques de précision.
Collecte en temps réel:
- Latence résolution par stratégie
- Taux de succès par environnement
- Confiance moyenne par type d'élément
- Patterns d'échec et récupération
"""
def __init__(self):
self.collectors: List[MetricsCollector] = []
self.analyzers: List[MetricsAnalyzer] = []
self.storage: TimeSeriesStorage = None
self.alerting: AlertManager = None
async def collect_resolution_metrics(
self,
target_spec: TargetSpec,
result: Optional[ResolvedTarget],
latency_ms: float,
environment_info: EnvironmentInfo
) -> None:
"""Collecter métriques d'une résolution"""
async def analyze_trends(
self,
time_window: timedelta
) -> PrecisionAnalysis:
"""Analyser tendances sur période donnée"""
async def detect_anomalies(self) -> List[Anomaly]:
"""Détecter anomalies dans métriques"""
```
#### Métriques Collectées
```python
@dataclass
class ResolutionMetrics:
"""Métriques d'une résolution individuelle"""
timestamp: datetime
target_spec: TargetSpec
success: bool
latency_ms: float
confidence: float
strategy_used: str
fallback_applied: bool
environment_hash: str
screen_resolution: Tuple[int, int]
dpi_scale: float
error_type: Optional[str] = None
recovery_time_ms: Optional[float] = None
@dataclass
class AggregatedMetrics:
"""Métriques agrégées par période"""
time_window: timedelta
total_resolutions: int
success_rate: float
avg_latency_ms: float
p95_latency_ms: float
p99_latency_ms: float
strategy_distribution: Dict[str, int]
environment_success_rates: Dict[str, float]
top_failure_patterns: List[FailurePattern]
```
### 2. Adaptive Calibrator
#### Architecture
```python
class AdaptiveCalibrator:
"""
Calibrateur adaptatif pour optimisation automatique des paramètres.
Fonctionnalités:
- Détection automatique environnement (DPI, résolution, thème)
- Ajustement seuils de confiance par contexte
- A/B testing configurations
- Rollback automatique si dégradation
"""
def __init__(self):
self.environment_detector = EnvironmentDetector()
self.threshold_optimizer = ThresholdOptimizer()
self.ab_tester = ABTester()
self.config_manager = ConfigurationManager()
async def detect_environment_change(
self,
screen_state: ScreenState
) -> Optional[EnvironmentChange]:
"""Détecter changement d'environnement"""
async def calibrate_thresholds(
self,
environment: EnvironmentInfo,
historical_metrics: List[ResolutionMetrics]
) -> CalibrationResult:
"""Calibrer seuils pour environnement donné"""
async def test_configuration(
self,
config_a: Configuration,
config_b: Configuration,
test_duration: timedelta
) -> ABTestResult:
"""Tester deux configurations en A/B"""
```
#### Détection d'Environnement
```python
@dataclass
class EnvironmentInfo:
"""Information sur l'environnement d'exécution"""
screen_resolution: Tuple[int, int]
dpi_scale: float
color_depth: int
os_version: str
browser_info: Optional[BrowserInfo]
ui_theme: str # "light", "dark", "high_contrast"
accessibility_mode: bool
zoom_level: float
def compute_hash(self) -> str:
"""Hash unique pour cet environnement"""
return hashlib.md5(
f"{self.screen_resolution}_{self.dpi_scale}_{self.ui_theme}_{self.zoom_level}"
.encode()
).hexdigest()
class EnvironmentDetector:
"""Détecteur d'environnement et changements"""
def detect_current_environment(self) -> EnvironmentInfo:
"""Détecter environnement actuel"""
def detect_ui_changes(
self,
previous_state: ScreenState,
current_state: ScreenState
) -> List[UIChange]:
"""Détecter changements UI entre deux états"""
def normalize_coordinates(
self,
bbox: Tuple[int, int, int, int],
source_env: EnvironmentInfo,
target_env: EnvironmentInfo
) -> Tuple[int, int, int, int]:
"""Normaliser coordonnées entre environnements"""
```
### 3. Robustness Manager
#### Architecture
```python
class RobustnessManager:
"""
Gestionnaire de robustesse multi-environnements.
Responsabilités:
- Normalisation DPI/résolution
- Adaptation zoom/échelle
- Stratégies de récupération
- Fallback intelligent
"""
def __init__(self):
self.normalizer = CoordinateNormalizer()
self.scale_adapter = ScaleAdapter()
self.recovery_strategies = RecoveryStrategyManager()
self.fallback_chains = FallbackChainManager()
async def resolve_with_robustness(
self,
target_spec: TargetSpec,
screen_state: ScreenState,
environment: EnvironmentInfo
) -> Optional[ResolvedTarget]:
"""Résolution robuste avec fallbacks"""
async def adapt_to_scale_change(
self,
original_elements: List[UIElement],
scale_factor: float
) -> List[UIElement]:
"""Adapter éléments à changement d'échelle"""
```
#### Stratégies de Récupération
```python
class RecoveryStrategy(ABC):
"""Stratégie de récupération abstraite"""
@abstractmethod
async def can_recover(
self,
failure: ResolutionFailure,
context: RecoveryContext
) -> bool:
"""Vérifier si cette stratégie peut récupérer"""
@abstractmethod
async def attempt_recovery(
self,
failure: ResolutionFailure,
context: RecoveryContext
) -> Optional[ResolvedTarget]:
"""Tenter récupération"""
class SpatialRecoveryStrategy(RecoveryStrategy):
"""Récupération par relations spatiales"""
class SemanticRecoveryStrategy(RecoveryStrategy):
"""Récupération par similarité sémantique"""
class TemplateRecoveryStrategy(RecoveryStrategy):
"""Récupération par matching de templates"""
```
### 4. Performance Optimizer
#### Architecture
```python
class PerformanceOptimizer:
"""
Optimiseur de performance pour résolution parallèle et cache intelligent.
Fonctionnalités:
- Résolution batch/parallèle
- Cache multi-niveaux
- Pool de workers
- Optimisation GPU/CPU
"""
def __init__(self):
self.parallel_resolver = ParallelResolver()
self.cache_manager = IntelligentCacheManager()
self.worker_pool = WorkerPoolManager()
self.resource_optimizer = ResourceOptimizer()
async def resolve_batch(
self,
target_specs: List[TargetSpec],
screen_state: ScreenState,
max_parallelism: int = 4
) -> List[Optional[ResolvedTarget]]:
"""Résoudre plusieurs cibles en parallèle"""
async def optimize_cache_strategy(
self,
usage_patterns: List[CacheUsagePattern]
) -> CacheConfiguration:
"""Optimiser stratégie de cache"""
```
#### Cache Multi-Niveaux
```python
class IntelligentCacheManager:
"""
Gestionnaire de cache intelligent multi-niveaux.
Niveaux:
1. L1: Résolutions récentes (LRU, 100 entrées)
2. L2: Embeddings par session (TTL 1h)
3. L3: Relations spatiales (TTL 30min)
4. L4: Configurations environnement (TTL 24h)
"""
def __init__(self):
self.l1_cache = LRUCache(maxsize=100) # Résolutions
self.l2_cache = TTLCache(maxsize=1000, ttl=3600) # Embeddings
self.l3_cache = TTLCache(maxsize=500, ttl=1800) # Relations
self.l4_cache = TTLCache(maxsize=50, ttl=86400) # Configs
async def get_cached_resolution(
self,
cache_key: str
) -> Optional[ResolvedTarget]:
"""Récupérer résolution du cache"""
async def cache_resolution(
self,
cache_key: str,
result: ResolvedTarget,
cache_level: int = 1
) -> None:
"""Mettre en cache une résolution"""
async def invalidate_on_ui_change(
self,
ui_change: UIChange
) -> None:
"""Invalider cache suite à changement UI"""
```
### 5. Monitoring Dashboard
#### Architecture Frontend (React/TypeScript)
```typescript
// Components principaux
interface MonitoringDashboardProps {
metricsEngine: PrecisionMetricsEngine;
realTimeUpdates: boolean;
}
const MonitoringDashboard: React.FC<MonitoringDashboardProps> = ({
metricsEngine,
realTimeUpdates
}) => {
return (
<div className="monitoring-dashboard">
<MetricsOverview />
<PrecisionTrends />
<EnvironmentComparison />
<AlertsPanel />
<PerformanceCharts />
</div>
);
};
// Hooks pour données temps réel
const useRealTimeMetrics = (refreshInterval: number = 5000) => {
const [metrics, setMetrics] = useState<AggregatedMetrics | null>(null);
const [loading, setLoading] = useState(true);
useEffect(() => {
const ws = new WebSocket('/api/metrics/stream');
ws.onmessage = (event) => {
const newMetrics = JSON.parse(event.data);
setMetrics(newMetrics);
setLoading(false);
};
return () => ws.close();
}, []);
return { metrics, loading };
};
```
#### API Backend (FastAPI)
```python
from fastapi import FastAPI, WebSocket
from fastapi.responses import HTMLResponse
app = FastAPI(title="RPA Precision Monitoring API")
@app.websocket("/api/metrics/stream")
async def metrics_websocket(websocket: WebSocket):
"""Stream temps réel des métriques"""
await websocket.accept()
async for metrics in metrics_engine.stream_metrics():
await websocket.send_json(metrics.dict())
@app.get("/api/metrics/summary")
async def get_metrics_summary(
time_window: str = "1h"
) -> AggregatedMetrics:
"""Résumé des métriques sur période"""
@app.get("/api/environments")
async def get_environments() -> List[EnvironmentInfo]:
"""Liste des environnements détectés"""
@app.post("/api/calibration/trigger")
async def trigger_calibration(
environment_id: str
) -> CalibrationResult:
"""Déclencher calibration pour environnement"""
```
## 🔄 Flux de Données et Intégrations
### Flux Principal de Résolution Améliorée
```mermaid
sequenceDiagram
participant Client
participant RobustnessManager
participant TargetResolver
participant MetricsEngine
participant AdaptiveCalibrator
participant CacheManager
Client->>RobustnessManager: resolve_target(spec, screen_state)
RobustnessManager->>CacheManager: check_cache(cache_key)
alt Cache Hit
CacheManager-->>RobustnessManager: cached_result
RobustnessManager-->>Client: result
else Cache Miss
RobustnessManager->>AdaptiveCalibrator: get_optimized_config(environment)
AdaptiveCalibrator-->>RobustnessManager: config
RobustnessManager->>TargetResolver: resolve_with_config(spec, config)
TargetResolver-->>RobustnessManager: result
RobustnessManager->>CacheManager: cache_result(key, result)
RobustnessManager->>MetricsEngine: record_metrics(spec, result, latency)
RobustnessManager-->>Client: result
end
MetricsEngine->>AdaptiveCalibrator: update_calibration_data(metrics)
```
### Intégration avec Composants Existants
#### Enhanced Target Resolver
```python
class EnhancedTargetResolver(TargetResolver):
"""
Version améliorée du TargetResolver avec support précision avancée.
Nouvelles fonctionnalités:
- Métriques intégrées
- Cache intelligent
- Adaptation environnement
- Récupération robuste
"""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.metrics_engine = PrecisionMetricsEngine()
self.robustness_manager = RobustnessManager()
self.performance_optimizer = PerformanceOptimizer()
async def resolve_target(
self,
target_spec: TargetSpec,
screen_state: ScreenState,
context: Optional[ResolutionContext] = None
) -> Optional[ResolvedTarget]:
"""Résolution avec améliorations précision"""
start_time = time.time()
environment = self.robustness_manager.detect_environment()
try:
# Tentative résolution robuste
result = await self.robustness_manager.resolve_with_robustness(
target_spec, screen_state, environment
)
# Enregistrer métriques succès
latency_ms = (time.time() - start_time) * 1000
await self.metrics_engine.collect_resolution_metrics(
target_spec, result, latency_ms, environment
)
return result
except Exception as e:
# Enregistrer métriques échec
latency_ms = (time.time() - start_time) * 1000
await self.metrics_engine.collect_resolution_metrics(
target_spec, None, latency_ms, environment
)
raise
```
## 📊 Modèles de Données
### Configuration et Calibration
```python
@dataclass
class PrecisionConfiguration:
"""Configuration de précision par environnement"""
environment_hash: str
similarity_threshold: float
position_tolerance: int
text_fuzzy_threshold: float
confidence_boost_factors: Dict[str, float]
cache_ttl_seconds: int
parallel_workers: int
# Seuils adaptatifs
adaptive_thresholds: Dict[str, AdaptiveThreshold]
# Stratégies de fallback
fallback_strategies: List[str]
# Métriques cibles
target_precision: float = 0.98
target_latency_ms: float = 50.0
@dataclass
class AdaptiveThreshold:
"""Seuil adaptatif avec historique"""
current_value: float
min_value: float
max_value: float
adjustment_history: List[ThresholdAdjustment]
last_calibration: datetime
@dataclass
class ThresholdAdjustment:
"""Ajustement de seuil"""
timestamp: datetime
old_value: float
new_value: float
reason: str
performance_impact: float
```
### Métriques et Alertes
```python
@dataclass
class Alert:
"""Alerte système"""
id: str
severity: AlertSeverity
title: str
description: str
timestamp: datetime
environment_hash: Optional[str]
metrics_snapshot: Dict[str, Any]
suggested_actions: List[str]
auto_resolution_attempted: bool = False
class AlertSeverity(Enum):
INFO = "info"
WARNING = "warning"
ERROR = "error"
CRITICAL = "critical"
@dataclass
class PerformanceBenchmark:
"""Benchmark de performance"""
test_name: str
environment: EnvironmentInfo
target_specs: List[TargetSpec]
results: List[BenchmarkResult]
summary_stats: BenchmarkSummary
timestamp: datetime
@dataclass
class BenchmarkResult:
"""Résultat individuel de benchmark"""
target_spec: TargetSpec
success: bool
latency_ms: float
confidence: float
strategy_used: str
memory_usage_mb: float
cpu_usage_percent: float
```
## 🧪 Stratégie de Tests
### Tests de Performance
```python
class TestPrecisionPerformance:
"""Tests de performance pour précision améliorée"""
@pytest.mark.performance
async def test_resolution_latency_targets(self):
"""Vérifier latences cibles respectées"""
resolver = EnhancedTargetResolver()
# Test résolution simple
simple_spec = TargetSpec(by_role="button")
start = time.time()
result = await resolver.resolve_target(simple_spec, mock_screen_state)
latency_ms = (time.time() - start) * 1000
assert latency_ms < 50, f"Simple resolution too slow: {latency_ms}ms"
assert result is not None, "Should find target"
@pytest.mark.performance
async def test_batch_resolution_throughput(self):
"""Vérifier throughput résolution batch"""
optimizer = PerformanceOptimizer()
specs = [TargetSpec(by_role=f"button_{i}") for i in range(10)]
start = time.time()
results = await optimizer.resolve_batch(specs, mock_screen_state)
duration = time.time() - start
throughput = len(specs) / duration
assert throughput > 20, f"Batch throughput too low: {throughput} res/s"
### Tests Multi-Environnements
```python
class TestMultiEnvironmentRobustness:
"""Tests robustesse multi-environnements"""
@pytest.mark.parametrize("resolution,dpi", [
((1920, 1080), 1.0),
((2560, 1440), 1.25),
((3840, 2160), 1.5),
])
async def test_resolution_consistency(self, resolution, dpi):
"""Vérifier cohérence sur différentes résolutions"""
env = EnvironmentInfo(
screen_resolution=resolution,
dpi_scale=dpi,
ui_theme="light",
zoom_level=1.0
)
manager = RobustnessManager()
result = await manager.resolve_with_robustness(
target_spec, screen_state, env
)
assert result is not None, f"Should resolve on {resolution}@{dpi}x"
assert result.confidence > 0.9, "High confidence expected"
```
### Tests d'Intégration
```python
class TestPrecisionIntegration:
"""Tests d'intégration système complet"""
async def test_end_to_end_precision_workflow(self):
"""Test workflow complet avec métriques"""
# Setup
metrics_engine = PrecisionMetricsEngine()
calibrator = AdaptiveCalibrator()
resolver = EnhancedTargetResolver()
# Exécution
results = []
for i in range(100):
result = await resolver.resolve_target(
random_target_spec(), random_screen_state()
)
results.append(result)
# Vérifications
success_rate = sum(1 for r in results if r is not None) / len(results)
assert success_rate > 0.95, f"Success rate too low: {success_rate}"
# Vérifier métriques collectées
metrics = await metrics_engine.get_recent_metrics(timedelta(minutes=5))
assert len(metrics) == 100, "All resolutions should be tracked"
```
## 🚀 Plan de Déploiement
### Phase 1: Infrastructure (Semaines 1-2)
1. **Setup métriques**: InfluxDB + Grafana
2. **Cache Redis**: Configuration multi-niveaux
3. **API monitoring**: FastAPI + WebSocket
4. **Tests baseline**: Benchmarks performance actuels
### Phase 2: Robustesse (Semaines 3-4)
1. **Détection environnement**: DPI, résolution, thème
2. **Normalisation coordonnées**: Cross-environment
3. **Stratégies récupération**: Spatial, sémantique, template
4. **Tests multi-env**: Validation 3+ environnements
### Phase 3: Performance (Semaines 5-6)
1. **Résolution parallèle**: Worker pool + batch API
2. **Cache intelligent**: Invalidation + optimisation
3. **Profiling**: Identification goulots d'étranglement
4. **Optimisation**: GPU/CPU, mémoire
### Phase 4: Monitoring (Semaines 7-8)
1. **Dashboard React**: Interface temps réel
2. **Alertes intelligentes**: Seuils adaptatifs
3. **Diagnostic auto**: Suggestions amélioration
4. **Documentation**: Guides utilisateur + API
---
**Prochaine étape**: Création du fichier de tâches détaillées pour l'implémentation.

315
.kiro/specs/rpa-precision-enhancement/requirements.md Normal file
View File

@@ -0,0 +1,315 @@
# RPA Precision Enhancement - Spécification des Exigences
**Auteur**: Dom, Alice Kiro
**Date**: 15 décembre 2024
**Version**: 1.0
**Statut**: Nouveau
## 🎯 Vue d'Ensemble
Suite aux corrections réussies des Fiches #1, #2, et #3 qui ont résolu les bugs critiques de précision ("robot qui clique à côté"), cette spécification définit la prochaine phase d'amélioration du système RPA Vision V3 pour atteindre une précision de niveau production.
## 📋 Contexte et Motivation
### Succès Actuels ✅
- **Fiche #1**: Contrats de données unifiés (aliases de compatibilité)
- **Fiche #2**: Format BBOX XYWH standardisé (précision géométrique)
- **Fiche #3**: Context hints intégrés dans résolution composite
- **Précision actuelle**: ~95% (amélioration de +35% depuis les corrections)
### Défis Restants 🎯
1. **Robustesse multi-environnements**: Variations d'écran, résolutions, DPI
2. **Adaptation dynamique**: UI qui changent (mises à jour, thèmes)
3. **Performance à l'échelle**: Optimisation pour workflows complexes
4. **Monitoring avancé**: Métriques de précision en temps réel
5. **Auto-amélioration**: Apprentissage continu des échecs
## 🎯 Objectifs Principaux
### Objectif 1: Précision Robuste Multi-Environnements
- **Cible**: 98%+ de précision sur différentes résolutions/DPI
- **Métriques**: Taux de succès par environnement, écart-type des positions
- **Valeur**: Déploiement fiable sur parcs hétérogènes
### Objectif 2: Adaptation Dynamique UI
- **Cible**: Détection automatique des changements UI et re-calibration
- **Métriques**: Temps de récupération après changement UI, taux de faux positifs
- **Valeur**: Maintenance réduite, workflows auto-résilients
### Objectif 3: Performance Optimisée
- **Cible**: <50ms résolution moyenne, <200ms pour cas complexes
- **Métriques**: Latence P95, throughput résolutions/seconde
- **Valeur**: Workflows fluides, expérience utilisateur améliorée
### Objectif 4: Monitoring Intelligent
- **Cible**: Dashboard temps réel avec alertes prédictives
- **Métriques**: MTTR (Mean Time To Recovery), précision par composant
- **Valeur**: Proactivité opérationnelle, debugging facilité
## 👥 Personas et Cas d'Usage
### Persona 1: Administrateur RPA
**Besoins**:
- Monitoring centralisé de la précision
- Alertes automatiques sur dégradation
- Métriques de performance par workflow
**Cas d'usage**:
- Surveiller 50+ workflows en production
- Détecter rapidement les régressions
- Optimiser les configurations par environnement
### Persona 2: Développeur Workflow
**Besoins**:
- Outils de debugging précision
- Feedback temps réel sur qualité résolution
- Suggestions d'amélioration automatiques
**Cas d'usage**:
- Créer workflows robustes multi-environnements
- Diagnostiquer échecs de résolution
- Optimiser sélecteurs pour performance
### Persona 3: Utilisateur Final
**Besoins**:
- Workflows qui "marchent toujours"
- Récupération transparente des erreurs
- Performance constante
**Cas d'usage**:
- Exécuter workflows quotidiens sans intervention
- Travailler sur différents postes/résolutions
- Bénéficier d'améliorations automatiques
## 📋 User Stories
### Epic 1: Robustesse Multi-Environnements
#### US-1.1: Normalisation DPI/Résolution
**En tant qu'** administrateur RPA
**Je veux** que les workflows fonctionnent identiquement sur différentes résolutions
**Afin de** déployer sur un parc hétérogène sans reconfiguration
**Critères d'acceptation**:
- [ ] Détection automatique DPI/résolution
- [ ] Normalisation coordonnées BBOX
- [ ] Tests sur 3+ résolutions différentes
- [ ] Précision >95% sur chaque environnement
#### US-1.2: Adaptation Échelle UI
**En tant que** développeur workflow
**Je veux** que les éléments soient trouvés même avec zoom/échelle différents
**Afin de** créer des workflows universels
**Critères d'acceptation**:
- [ ] Support zoom 75%-150%
- [ ] Recalibration automatique des seuils
- [ ] Métriques de confiance ajustées
- [ ] Fallback multi-échelle
### Epic 2: Adaptation Dynamique
#### US-2.1: Détection Changements UI
**En tant qu'** utilisateur final
**Je veux** que mes workflows continuent de fonctionner après mises à jour UI
**Afin de** ne pas avoir à les reconfigurer constamment
**Critères d'acceptation**:
- [ ] Détection automatique changements layout
- [ ] Stratégies de récupération adaptatives
- [ ] Apprentissage des nouveaux patterns
- [ ] Notification changements détectés
#### US-2.2: Auto-Calibration Seuils
**En tant que** système RPA
**Je veux** ajuster automatiquement mes seuils de confiance
**Afin de** maintenir une précision optimale
**Critères d'acceptation**:
- [ ] Analyse historique des succès/échecs
- [ ] Ajustement dynamique des seuils
- [ ] A/B testing des configurations
- [ ] Rollback automatique si dégradation
### Epic 3: Performance Optimisée
#### US-3.1: Cache Intelligent
**En tant que** système RPA
**Je veux** un cache multi-niveaux optimisé
**Afin de** réduire la latence de résolution
**Critères d'acceptation**:
- [ ] Cache embeddings par session
- [ ] Cache relations spatiales
- [ ] Invalidation intelligente
- [ ] Métriques hit rate >80%
#### US-3.2: Résolution Parallèle
**En tant que** développeur workflow
**Je veux** résoudre plusieurs cibles en parallèle
**Afin d** accélérer les workflows complexes
**Critères d'acceptation**:
- [ ] API résolution batch
- [ ] Pool de workers configurables
- [ ] Gestion ressources GPU/CPU
- [ ] Latence réduite 50%+ pour batch
### Epic 4: Monitoring Avancé
#### US-4.1: Dashboard Précision Temps Réel
**En tant qu'** administrateur RPA
**Je veux** un dashboard temps réel de la précision
**Afin de** détecter rapidement les problèmes
**Critères d'acceptation**:
- [ ] Métriques temps réel par workflow
- [ ] Graphiques tendances précision
- [ ] Alertes seuils configurables
- [ ] Export données pour analyse
#### US-4.2: Diagnostic Automatique
**En tant que** développeur workflow
**Je veux** des suggestions automatiques d'amélioration
**Afin d'** optimiser mes sélecteurs
**Critères d'acceptation**:
- [ ] Analyse patterns d'échec
- [ ] Suggestions sélecteurs alternatifs
- [ ] Scoring qualité résolution
- [ ] Recommandations performance
## 🔧 Exigences Techniques
### Performance
- **Latence résolution**: <50ms P95 (simple), <200ms P95 (composite)
- **Throughput**: >100 résolutions/seconde
- **Mémoire**: <500MB overhead cache
- **CPU**: <10% utilisation baseline
### Fiabilité
- **Précision**: >98% multi-environnements
- **Disponibilité**: 99.9% uptime
- **Récupération**: <5s après changement UI
- **Cohérence**: Résultats identiques multi-exécutions
### Scalabilité
- **Workflows simultanés**: >50
- **Éléments UI**: >1000 par écran
- **Historique**: 30 jours métriques
- **Environnements**: Support 10+ configurations
### Sécurité
- **Données sensibles**: Pas de capture credentials
- **Logs**: Anonymisation automatique
- **Accès**: RBAC pour monitoring
- **Audit**: Traçabilité complète actions
## 🚫 Exclusions
### Hors Périmètre v1.0
- **OCR avancé**: Reconnaissance texte complexe (v2.0)
- **IA générative**: Génération workflows automatique (v2.0)
- **Multi-applications**: Workflows cross-app (v1.1)
- **Mobile**: Support tablettes/smartphones (v2.0)
### Contraintes Acceptées
- **Environnements supportés**: Windows 10+, macOS 12+, Ubuntu 20+
- **Navigateurs**: Chrome 90+, Firefox 88+, Edge 90+
- **Résolutions**: 1024x768 à 4K
- **Langues**: Interface anglais/français uniquement
## 📊 Métriques de Succès
### Métriques Primaires
1. **Précision Globale**: >98% (vs 95% actuel)
2. **Latence P95**: <50ms simple, <200ms composite
3. **MTTR**: <5 minutes (vs 30 minutes actuel)
4. **Satisfaction Utilisateur**: >4.5/5 (enquête)
### Métriques Secondaires
1. **Cache Hit Rate**: >80%
2. **False Positive Rate**: <2%
3. **Adaptation Time**: <10s après changement UI
4. **Resource Efficiency**: <10% CPU, <500MB RAM
### Métriques de Qualité
1. **Code Coverage**: >90%
2. **Performance Tests**: 100% passing
3. **Security Scan**: 0 vulnérabilités critiques
4. **Documentation**: 100% APIs documentées
## 🗓️ Jalons et Livrables
### Phase 1: Fondations (Semaines 1-2)
- [ ] Architecture monitoring avancé
- [ ] Framework métriques temps réel
- [ ] Cache multi-niveaux
- [ ] Tests performance baseline
### Phase 2: Robustesse (Semaines 3-4)
- [ ] Normalisation DPI/résolution
- [ ] Adaptation multi-échelle
- [ ] Détection changements UI
- [ ] Stratégies récupération
### Phase 3: Performance (Semaines 5-6)
- [ ] Résolution parallèle
- [ ] Optimisations cache
- [ ] Profiling et tuning
- [ ] Benchmarks comparatifs
### Phase 4: Monitoring (Semaines 7-8)
- [ ] Dashboard temps réel
- [ ] Alertes intelligentes
- [ ] Diagnostic automatique
- [ ] Documentation utilisateur
## 🔗 Dépendances
### Dépendances Internes
- **Core Models**: Contrats données stabilisés (Fiches #1-3) ✅
- **Target Resolver**: Context hints implémentés (Fiche #3) ✅
- **Action Executor**: Précision BBOX corrigée (Fiche #2) ✅
- **Analytics System**: Infrastructure existante
### Dépendances Externes
- **Monitoring Stack**: Prometheus/Grafana ou équivalent
- **Cache Backend**: Redis ou équivalent
- **GPU Resources**: CUDA 11+ pour optimisations
- **Testing Infrastructure**: Environnements multi-résolution
## ⚠️ Risques et Mitigation
### Risques Techniques
1. **Performance Dégradation**: Monitoring peut impacter latence
- *Mitigation*: Sampling intelligent, async processing
2. **Cache Invalidation**: Complexité gestion cohérence
- *Mitigation*: Stratégies TTL conservatrices, validation
3. **Multi-threading**: Race conditions résolution parallèle
- *Mitigation*: Design thread-safe, tests concurrence
### Risques Produit
1. **Over-engineering**: Complexité vs bénéfice utilisateur
- *Mitigation*: MVP itératif, feedback utilisateur continu
2. **Adoption**: Résistance changement workflows existants
- *Mitigation*: Rétrocompatibilité, migration progressive
3. **Maintenance**: Overhead opérationnel monitoring
- *Mitigation*: Automation maximale, self-healing
## 📚 Références
### Standards et Bonnes Pratiques
- **W3C Accessibility Guidelines**: Pour sélecteurs robustes
- **IEEE 829**: Standards documentation tests
- **ISO 25010**: Qualité logiciel (performance, fiabilité)
### Technologies de Référence
- **Selenium Grid**: Architecture parallélisation
- **Prometheus**: Métriques et monitoring
- **OpenTelemetry**: Observabilité distribuée
- **Apache Kafka**: Streaming métriques temps réel
---
**Prochaine étape**: Création du document de design détaillé basé sur ces exigences.

458
.kiro/specs/rpa-precision-enhancement/tasks.md Normal file
View File

@@ -0,0 +1,458 @@
# RPA Precision Enhancement - Tâches Détaillées
**Auteur**: Dom, Alice Kiro
**Date**: 15 décembre 2024
**Version**: 1.0
**Statut**: Prêt pour implémentation
## 🎯 Vue d'Ensemble des Tâches
Basé sur les succès des Fiches #1-3 (précision +35%), cette spécification définit 32 tâches organisées en 4 phases pour atteindre 98%+ de précision avec monitoring intelligent.
### Progression Actuelle ✅
- **Fiche #1**: Contrats données unifiés (aliases compatibilité)
- **Fiche #2**: BBOX XYWH standardisé (géométrie correcte)
- **Fiche #3**: Context hints intégrés (résolution composite)
- **Précision**: 95% (vs 60% initial)
### Objectif Final 🎯
- **Précision**: 98%+ multi-environnements
- **Latence**: <50ms P95 simple, <200ms composite
- **Robustesse**: Auto-adaptation UI changes
- **Monitoring**: Dashboard temps réel + alertes
---
## 📋 Phase 1: Infrastructure Monitoring (Semaines 1-2)
### Tâche 1.1: Precision Metrics Engine
**Priorité**: Critique
**Estimation**: 3 jours
**Dépendances**: Aucune
**Description**: Créer le moteur de collecte métriques temps réel
**Sous-tâches**:
- [ ] **1.1.1**: Créer `core/precision/metrics_engine.py`
- [ ] **1.1.2**: Définir modèles données métriques
- [ ] **1.1.3**: Intégrer collecte dans `EnhancedTargetResolver`
- [ ] **1.1.4**: Tests unitaires + benchmarks performance
**Critères d'acceptation**:
- [ ] Collecte <1ms overhead par résolution
- [ ] Support 1000+ métriques/seconde
- [ ] Stockage TimeSeries (InfluxDB/Prometheus)
- [ ] API REST pour requêtes historiques
---
### Tâche 1.2: Time Series Storage Setup
**Priorité**: Critique
**Estimation**: 2 jours
**Dépendances**: 1.1
**Description**: Configuration stockage métriques haute performance
**Sous-tâches**:
- [ ] **1.2.1**: Setup InfluxDB ou Prometheus
- [ ] **1.2.2**: Schémas données optimisés
- [ ] **1.2.3**: Rétention policies (30 jours détail, 1 an agrégé)
- [ ] **1.2.4**: Backup/restore automatique
**Critères d'acceptation**:
- [ ] Ingestion >10k points/seconde
- [ ] Requêtes <100ms P95
- [ ] Compression >80%
- [ ] HA avec réplication
---
### Tâche 1.3: Cache Multi-Niveaux
**Priorité**: Haute
**Estimation**: 4 jours
**Dépendances**: Aucune
**Description**: Cache intelligent pour optimisation performance
**Critères d'acceptation**:
- [ ] Hit rate >80% après warm-up
- [ ] Latence cache <1ms P95
- [ ] Invalidation <10ms après UI change
- [ ] Mémoire <500MB overhead
---
### Tâche 1.4: Performance Baseline Tests
**Priorité**: Haute
**Estimation**: 2 jours
**Dépendances**: 1.1, 1.3
**Description**: Établir benchmarks performance actuels
**Critères d'acceptation**:
- [ ] Tests automatisés CI/CD
- [ ] Régression detection <5%
- [ ] Profiling complet call stacks
- [ ] Dashboard performance continu
---
## 📋 Phase 2: Robustesse Multi-Environnements (Semaines 3-4)
### Tâche 2.1: Environment Detection
**Priorité**: Critique
**Estimation**: 3 jours
**Dépendances**: 1.1
**Description**: Détection automatique environnement (DPI, résolution, thème)
**Critères d'acceptation**:
- [ ] Détection <50ms
- [ ] Support 3+ OS
- [ ] Précision DPI 100%
- [ ] Hash stable par environnement
---
### Tâche 2.2: Coordinate Normalization
**Priorité**: Critique
**Estimation**: 4 jours
**Dépendances**: 2.1
**Description**: Normalisation coordonnées cross-environment
**Critères d'acceptation**:
- [ ] Précision <2px après normalisation
- [ ] Support résolutions 1024x768 à 4K
- [ ] Support DPI 100%-300%
- [ ] Tests 5+ environnements différents
---
### Tâche 2.3: Adaptive Calibrator
**Priorité**: Haute
**Estimation**: 5 jours
**Dépendances**: 2.1, 2.2
**Description**: Calibration automatique seuils par environnement
**Critères d'acceptation**:
- [ ] Amélioration précision >5% après calibration
- [ ] Convergence <100 échantillons
- [ ] A/B tests statistiquement significatifs
- [ ] Rollback <30s si problème
---
### Tâche 2.4: Recovery Strategies
**Priorité**: Haute
**Estimation**: 4 jours
**Dépendances**: 2.2, 2.3
**Description**: Stratégies récupération après échec résolution
**Critères d'acceptation**:
- [ ] Récupération >70% échecs initiaux
- [ ] Latence récupération <500ms
- [ ] Chaîne fallback configurable
- [ ] Métriques efficacité par stratégie
---
### Tâche 2.5: UI Change Detection
**Priorité**: Moyenne
**Estimation**: 3 jours
**Dépendances**: 2.1
**Description**: Détection automatique changements UI
**Critères d'acceptation**:
- [ ] Détection changements >90%
- [ ] Faux positifs <5%
- [ ] Latence détection <100ms
- [ ] Intégration cache invalidation
---
## 📋 Phase 3: Performance Optimization (Semaines 5-6)
### Tâche 3.1: Parallel Resolution Engine
**Priorité**: Haute
**Estimation**: 4 jours
**Dépendances**: 1.3
**Description**: Résolution parallèle pour workflows complexes
**Critères d'acceptation**:
- [ ] Throughput >100 résolutions/seconde
- [ ] Latence batch 50%+ plus rapide
- [ ] Utilisation CPU optimale
- [ ] Pas de race conditions
---
### Tâche 3.2: GPU Optimization
**Priorité**: Moyenne
**Estimation**: 3 jours
**Dépendances**: 3.1
**Description**: Optimisation utilisation GPU pour embeddings
**Critères d'acceptation**:
- [ ] Throughput embeddings 3x+ plus rapide
- [ ] Utilisation VRAM optimale
- [ ] Pas de memory leaks
- [ ] Graceful degradation CPU
---
### Tâche 3.3: Cache Optimization
**Priorité**: Haute
**Estimation**: 3 jours
**Dépendances**: 1.3, 2.5
**Description**: Optimisation stratégies cache et invalidation
**Critères d'acceptation**:
- [ ] Hit rate >85%
- [ ] Réduction mémoire 30%+
- [ ] Prefetch accuracy >60%
- [ ] Latence cache <0.5ms P95
---
### Tâche 3.4: Memory Optimization
**Priorité**: Moyenne
**Estimation**: 2 jours
**Dépendances**: 3.1, 3.3
**Description**: Optimisation utilisation mémoire
**Critères d'acceptation**:
- [ ] Réduction mémoire 40%+
- [ ] Pas de memory leaks
- [ ] GC pauses <10ms
- [ ] Memory growth linéaire
---
### Tâche 3.5: Performance Profiling
**Priorité**: Haute
**Estimation**: 2 jours
**Dépendances**: 3.1, 3.2, 3.3
**Description**: Profiling complet et identification goulots
**Critères d'acceptation**:
- [ ] Identification top 10 bottlenecks
- [ ] Recommandations optimisation
- [ ] Profiling automatisé CI/CD
- [ ] Métriques performance continues
---
## 📋 Phase 4: Monitoring Dashboard (Semaines 7-8)
### Tâche 4.1: Real-Time Metrics API
**Priorité**: Critique
**Estimation**: 3 jours
**Dépendances**: 1.1, 1.2
**Description**: API REST + WebSocket pour métriques temps réel
**Critères d'acceptation**:
- [ ] Latence API <50ms P95
- [ ] Support 100+ connexions WebSocket
- [ ] Authentification JWT
- [ ] Documentation OpenAPI complète
---
### Tâche 4.2: React Dashboard Frontend
**Priorité**: Critique
**Estimation**: 5 jours
**Dépendances**: 4.1
**Description**: Interface web monitoring temps réel
**Critères d'acceptation**:
- [ ] Updates temps réel <1s latence
- [ ] Support mobile/tablet
- [ ] Accessibilité WCAG 2.1 AA
- [ ] Performance Lighthouse >90
---
### Tâche 4.3: Intelligent Alerting
**Priorité**: Haute
**Estimation**: 3 jours
**Dépendances**: 1.1, 4.1
**Description**: Système alertes intelligent avec ML
**Critères d'acceptation**:
- [ ] Détection anomalies >95%
- [ ] Faux positifs <2%
- [ ] Latence alerte <30s
- [ ] Escalation automatique
---
### Tâche 4.4: Diagnostic Automation
**Priorité**: Moyenne
**Estimation**: 4 jours
**Dépendances**: 2.4, 4.3
**Description**: Diagnostic automatique et suggestions
**Critères d'acceptation**:
- [ ] Suggestions pertinentes >80%
- [ ] Diagnostic <5s
- [ ] Intégration dashboard
- [ ] Export rapports PDF
---
### Tâche 4.5: Dashboard Integration
**Priorité**: Haute
**Estimation**: 2 jours
**Dépendances**: 4.2, 4.3, 4.4
**Description**: Intégration complète dashboard avec RPA Vision V3
**Critères d'acceptation**:
- [ ] Navigation seamless
- [ ] Authentification unifiée
- [ ] Performance production
- [ ] Monitoring uptime >99.9%
---
## 📋 Tâches Transversales
### Tâche T.1: Enhanced Target Resolver
**Priorité**: Critique
**Estimation**: 3 jours
**Dépendances**: 1.1, 1.3, 2.3
**Description**: Intégration améliorations dans TargetResolver existant
**Critères d'acceptation**:
- [ ] Rétrocompatibilité 100%
- [ ] Performance égale ou meilleure
- [ ] Migration transparente
- [ ] Tests existants passent
---
### Tâche T.2: Configuration Management
**Priorité**: Haute
**Estimation**: 2 jours
**Dépendances**: 2.3
**Description**: Gestion configuration centralisée
**Critères d'acceptation**:
- [ ] Configuration centralisée
- [ ] Validation automatique
- [ ] Hot reload <5s
- [ ] Backward compatibility
---
### Tâche T.3: Testing Infrastructure
**Priorité**: Haute
**Estimation**: 4 jours
**Dépendances**: Toutes phases
**Description**: Infrastructure tests complète
**Critères d'acceptation**:
- [ ] Coverage >90%
- [ ] Tests CI/CD <10min
- [ ] Tests performance automatiques
- [ ] Validation 3+ environnements
---
### Tâche T.4: Documentation
**Priorité**: Moyenne
**Estimation**: 3 jours
**Dépendances**: Toutes phases
**Description**: Documentation complète utilisateur et développeur
**Critères d'acceptation**:
- [ ] Documentation à jour
- [ ] Exemples fonctionnels
- [ ] Screenshots/vidéos
- [ ] Feedback utilisateurs positif
---
## 📊 Métriques de Validation
### Métriques Techniques
- **Précision globale**: >98% (vs 95% actuel)
- **Latence P95**: <50ms simple, <200ms composite
- **Cache hit rate**: >80%
- **Throughput**: >100 résolutions/seconde
- **Memory usage**: <500MB overhead
- **CPU usage**: <10% baseline
### Métriques Qualité
- **Code coverage**: >90%
- **Performance tests**: 100% passing
- **Security scan**: 0 vulnérabilités critiques
- **Documentation**: 100% APIs documentées
### Métriques Utilisateur
- **MTTR**: <5 minutes (vs 30 minutes actuel)
- **False positive rate**: <2%
- **Adaptation time**: <10s après UI change
- **User satisfaction**: >4.5/5
---
## 🗓️ Planning Détaillé
### Semaine 1-2: Infrastructure
- **Jours 1-3**: Tâches 1.1, 1.2 (Metrics + Storage)
- **Jours 4-7**: Tâches 1.3, 1.4 (Cache + Baseline)
- **Jours 8-10**: Tâche T.1 (Enhanced Resolver)
### Semaine 3-4: Robustesse
- **Jours 11-13**: Tâches 2.1, 2.2 (Environment + Normalization)
- **Jours 14-18**: Tâches 2.3, 2.4 (Calibrator + Recovery)
- **Jours 19-21**: Tâche 2.5 (UI Change Detection)
### Semaine 5-6: Performance
- **Jours 22-25**: Tâches 3.1, 3.2 (Parallel + GPU)
- **Jours 26-28**: Tâches 3.3, 3.4 (Cache + Memory)
- **Jours 29-30**: Tâche 3.5 (Profiling)
### Semaine 7-8: Monitoring
- **Jours 31-33**: Tâches 4.1, 4.2 (API + Dashboard)
- **Jours 34-36**: Tâches 4.3, 4.4 (Alerting + Diagnostic)
- **Jours 37-40**: Tâches 4.5, T.2-T.4 (Integration + Finition)
---
## ⚠️ Risques et Mitigation
### Risques Techniques
1. **Performance dégradation monitoring**: Sampling + async
2. **Cache invalidation complexité**: TTL conservateur + validation
3. **Multi-threading race conditions**: Thread-safe design + tests
### Risques Planning
1. **Sous-estimation complexité ML**: Buffer 20% + MVP itératif
2. **Dépendances externes**: Alternatives + fallbacks
3. **Integration breaking changes**: Feature flags + rollback
---
**Status**: ✅ **SPÉCIFICATION COMPLÈTE**
**Prochaine étape**: Sélection tâches prioritaires pour démarrage implémentation
Les Fiches #1-3 ont posé des fondations solides. Cette spécification définit la roadmap pour atteindre la précision de niveau production avec monitoring intelligent ! 🚀