v1.0 - Version stable: multi-PC, détection UI-DETR-1, 3 modes exécution

- Frontend v4 accessible sur réseau local (192.168.1.40)
- Ports ouverts: 3002 (frontend), 5001 (backend), 5004 (dashboard)
- Ollama GPU fonctionnel
- Self-healing interactif
- Dashboard confiance

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

core/interfaces/__init__.py

@@ -0,0 +1,18 @@
+"""
+Interfaces abstraites pour le découplage des composants.
+
+Ces interfaces permettent de découpler les composants et faciliter les tests.
+
+Auteur: Dom, Alice Kiro
+Date: 20 décembre 2024
+"""
+
+from .target_resolver_interface import ITargetResolver
+from .action_executor_interface import IActionExecutor
+from .error_handler_interface import IErrorHandler
+
+__all__ = [
+    "ITargetResolver",
+    "IActionExecutor",
+    "IErrorHandler",
+]

core/interfaces/action_executor_interface.py

@@ -0,0 +1,48 @@
+"""
+Interface abstraite pour ActionExecutor.
+
+Permet le découplage et facilite les tests avec mocking.
+
+Auteur: Dom, Alice Kiro
+Date: 20 décembre 2024
+"""
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from core.models.workflow_graph import Action
+    from core.models.screen_state import ScreenState
+    from core.execution.action_executor import ExecutionResult
+
+
+class IActionExecutor(ABC):
+    """Interface abstraite pour l'exécution d'actions"""
+    
+    @abstractmethod
+    def execute_action(self, action: 'Action', 
+                      screen_state: 'ScreenState') -> 'ExecutionResult':
+        """
+        Exécute une action sur l'état d'écran donné
+        
+        Args:
+            action: Action à exécuter
+            screen_state: État d'écran actuel
+            
+        Returns:
+            ExecutionResult avec le résultat de l'exécution
+        """
+        pass
+    
+    @abstractmethod
+    def can_execute(self, action: 'Action') -> bool:
+        """
+        Vérifie si l'action peut être exécutée
+        
+        Args:
+            action: Action à vérifier
+            
+        Returns:
+            True si l'action peut être exécutée, False sinon
+        """
+        pass

core/interfaces/error_handler_interface.py

@@ -0,0 +1,56 @@
+"""
+Interface abstraite pour ErrorHandler.
+
+Permet le découplage et facilite les tests avec mocking.
+
+Auteur: Dom, Alice Kiro
+Date: 20 décembre 2024
+"""
+
+from abc import ABC, abstractmethod
+from typing import Dict, Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from core.execution.recovery_strategies import RecoveryResult
+
+
+class IErrorHandler(ABC):
+    """Interface abstraite pour la gestion d'erreurs"""
+    
+    @abstractmethod
+    def handle_error(self, error: Exception, context: Dict[str, Any]) -> 'RecoveryResult':
+        """
+        Gère une erreur avec stratégie de récupération appropriée
+        
+        Args:
+            error: Exception à traiter
+            context: Contexte de l'erreur
+            
+        Returns:
+            RecoveryResult avec le résultat de la récupération
+        """
+        pass
+    
+    @abstractmethod
+    def register_strategy(self, error_type: type, strategy) -> None:
+        """
+        Enregistre une stratégie de récupération pour un type d'erreur
+        
+        Args:
+            error_type: Type d'erreur
+            strategy: Stratégie de récupération
+        """
+        pass
+    
+    @abstractmethod
+    def can_handle(self, error: Exception) -> bool:
+        """
+        Vérifie si l'erreur peut être gérée
+        
+        Args:
+            error: Exception à vérifier
+            
+        Returns:
+            True si l'erreur peut être gérée, False sinon
+        """
+        pass

core/interfaces/target_resolver_interface.py

@@ -0,0 +1,52 @@
+"""
+Interface abstraite pour TargetResolver.
+
+Permet le découplage et facilite les tests avec mocking.
+
+Auteur: Dom, Alice Kiro
+Date: 20 décembre 2024
+"""
+
+from abc import ABC, abstractmethod
+from typing import List, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from core.models.ui_element import UIElement
+    from core.models.workflow_graph import TargetSpec
+    from core.execution.target_resolver import ResolvedTarget
+
+
+class ITargetResolver(ABC):
+    """Interface abstraite pour la résolution de cibles"""
+    
+    @abstractmethod
+    def resolve_target(self, target_spec: 'TargetSpec', 
+                      ui_elements: List['UIElement']) -> Optional['ResolvedTarget']:
+        """
+        Résout une cible dans une liste d'éléments UI
+        
+        Args:
+            target_spec: Spécification de la cible à résoudre
+            ui_elements: Liste des éléments UI disponibles
+            
+        Returns:
+            ResolvedTarget si trouvé, None sinon
+        """
+        pass
+    
+    @abstractmethod
+    def resolve_with_context(self, target_spec: 'TargetSpec',
+                           ui_elements: List['UIElement'],
+                           context: dict) -> Optional['ResolvedTarget']:
+        """
+        Résout une cible avec contexte additionnel
+        
+        Args:
+            target_spec: Spécification de la cible
+            ui_elements: Liste des éléments UI
+            context: Contexte additionnel pour la résolution
+            
+        Returns:
+            ResolvedTarget si trouvé, None sinon
+        """
+        pass