django-lucy-assist 1.0.6__py3-none-any.whl → 1.0.8__py3-none-any.whl

lucy_assist/services/tool_executor_service.py

@@ -47,6 +47,7 @@ class ToolExecutorService:
         handlers = {
             'create_object': self._handle_create_object,
             'update_object': self._handle_update_object,
+            'get_deletion_impact': self._handle_get_deletion_impact,
             'delete_object': self._handle_delete_object,
             'search_objects': self._handle_search_objects,
             'get_object_details': self._handle_get_object_details,
@@ -110,11 +111,41 @@ class ToolExecutorService:
 
         return self.crud_service.update_object(app_name, model_name, object_id, data)
 
+    def _handle_get_deletion_impact(self, params: Dict) -> Dict:
+        """
+        Analyse l'impact d'une suppression avant de l'exécuter.
+        Retourne la liste de toutes les conséquences (cascade, SET_NULL, etc.)
+        """
+        app_name = params.get('app_name') or get_app_for_model(params.get('model_name', ''))
+        model_name = params.get('model_name', '')
+        object_id = params.get('object_id')
+
+        if not model_name:
+            return {'error': 'model_name est requis'}
+
+        if not object_id:
+            return {'error': 'object_id est requis'}
+
+        # Analyser l'impact
+        impact = self.crud_service.get_deletion_impact(app_name, model_name, object_id)
+
+        # Formater le message pour l'utilisateur
+        impact['formatted_message'] = self.crud_service.format_deletion_impact_message(impact)
+
+        return {
+            'success': True,
+            'impact': impact
+        }
+
     def _handle_delete_object(self, params: Dict) -> Dict:
-        """Supprime un objet."""
+        """
+        Supprime un objet.
+        Requiert que l'utilisateur ait explicitement confirmé après avoir vu l'impact.
+        """
         app_name = params.get('app_name') or get_app_for_model(params.get('model_name', ''))
         model_name = params.get('model_name', '')
         object_id = params.get('object_id')
+        confirmed = params.get('confirmed', False)
 
         if not model_name:
             return {'error': 'model_name est requis'}
@@ -122,6 +153,15 @@ class ToolExecutorService:
         if not object_id:
             return {'error': 'object_id est requis'}
 
+        # Vérifier que la confirmation a été donnée
+        if not confirmed:
+            return {
+                'error': 'Confirmation requise. Utilisez d\'abord get_deletion_impact pour voir les conséquences, '
+                         'puis demandez confirmation à l\'utilisateur avant de supprimer.',
+                'requires_confirmation': True
+            }
+
+        # Exécuter la suppression
         return self.crud_service.delete_object(app_name, model_name, object_id)
 
     def _handle_search_objects(self, params: Dict) -> Dict:

lucy_assist/services/tools_definition.py

@@ -10,7 +10,7 @@ LUCY_ASSIST_TOOLS = [
     {
         "name": "create_object",
         "description": """Crée un nouvel objet dans la base de données.
-        Utilise ce tool quand l'utilisateur demande de créer un objet métier (client, réservation, etc.).
+        Utilise ce tool quand l'utilisateur demande de créer un objet métier (client, facture, etc.).
         IMPORTANT: Utilise ce tool en priorité quand l'utilisateur demande une création.
         Ne demande pas de confirmation, exécute directement l'action.""",
         "input_schema": {
@@ -18,11 +18,11 @@ LUCY_ASSIST_TOOLS = [
             "properties": {
                 "app_name": {
                     "type": "string",
-                    "description": "Nom de l'application Django (ex: client, reservation, franchise)"
+                    "description": "Nom de l'application Django (ex: client, facture)"
                 },
                 "model_name": {
                     "type": "string",
-                    "description": "Nom du modèle Django (ex: Client, Reservation, Franchise)"
+                    "description": "Nom du modèle Django (ex: Client, Facture)"
                 },
                 "data": {
                     "type": "object",
@@ -62,11 +62,37 @@ LUCY_ASSIST_TOOLS = [
             "required": ["app_name", "model_name", "object_id", "data"]
         }
     },
+    {
+        "name": "get_deletion_impact",
+        "description": """Analyse l'impact d'une suppression AVANT de supprimer.
+        OBLIGATOIRE: Utilise TOUJOURS ce tool AVANT delete_object pour montrer à l'utilisateur
+        toutes les conséquences de la suppression (objets supprimés en cascade, champs mis à NULL, etc.)
+        Affiche le résultat à l'utilisateur et demande sa confirmation explicite avant de supprimer.""",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "app_name": {
+                    "type": "string",
+                    "description": "Nom de l'application Django"
+                },
+                "model_name": {
+                    "type": "string",
+                    "description": "Nom du modèle Django"
+                },
+                "object_id": {
+                    "type": "integer",
+                    "description": "ID de l'objet à analyser"
+                }
+            },
+            "required": ["app_name", "model_name", "object_id"]
+        }
+    },
     {
         "name": "delete_object",
         "description": """Supprime un objet de la base de données.
-        Utilise ce tool quand l'utilisateur demande explicitement de supprimer un objet.
-        ATTENTION: Demande confirmation avant de supprimer.""",
+        IMPORTANT: Tu DOIS d'abord utiliser get_deletion_impact pour analyser les conséquences,
+        puis afficher le résultat à l'utilisateur, et obtenir sa CONFIRMATION EXPLICITE avant d'exécuter ce tool.
+        Ne JAMAIS supprimer sans avoir montré l'impact et obtenu confirmation.""",
         "input_schema": {
             "type": "object",
             "properties": {
@@ -81,9 +107,13 @@ LUCY_ASSIST_TOOLS = [
                 "object_id": {
                     "type": "integer",
                     "description": "ID de l'objet à supprimer"
+                },
+                "confirmed": {
+                    "type": "boolean",
+                    "description": "OBLIGATOIRE: true si l'utilisateur a explicitement confirmé la suppression après avoir vu l'impact"
                 }
             },
-            "required": ["app_name", "model_name", "object_id"]
+            "required": ["app_name", "model_name", "object_id", "confirmed"]
         }
     },
     {

lucy_assist/services/view_discovery_service.py

@@ -0,0 +1,339 @@
+"""
+Service de découverte automatique des vues CRUD du projet.
+
+Parcourt les URL patterns Django pour identifier les vues CRUD
+et construire un mapping utilisable par Lucy Assist.
+"""
+import re
+from typing import Dict, List, Optional, Tuple
+from django.urls import URLPattern, URLResolver, get_resolver
+from django.urls.resolvers import RoutePattern
+
+from lucy_assist.utils.log_utils import LogUtils
+from lucy_assist.conf import lucy_assist_settings
+
+
+class ViewDiscoveryService:
+    """
+    Service pour découvrir automatiquement les vues CRUD d'un projet Django.
+    """
+
+    # Patterns de nommage courants pour les vues CRUD
+    # L'ordre est important : les patterns plus spécifiques doivent être en premier
+    CRUD_PATTERNS = {
+        'list': [
+            r'-list$', r'-liste$', r'-gestion$', r'-index$',
+            r'_list$', r'_liste$', r'_gestion$', r'_index$',
+            r'list$', r'liste$', r'gestion$'
+        ],
+        'create': [
+            r'-create$', r'-add$', r'-nouveau$', r'-new$',
+            r'_create$', r'_add$', r'_nouveau$', r'_new$',
+            r'create$', r'add$', r'nouveau$'
+        ],
+        'detail': [
+            r'-detail$', r'-view$', r'-show$', r'-fiche$', r'-consulter$',
+            r'_detail$', r'_view$', r'_show$', r'_fiche$',
+            r'detail$', r'view$', r'fiche$'
+        ],
+        'update': [
+            r'-update$', r'-edit$', r'-modifier$', r'-modification$',
+            r'_update$', r'_edit$', r'_modifier$',
+            r'update$', r'edit$', r'modifier$'
+        ],
+        'delete': [
+            r'-delete$', r'-suppression$', r'-supprimer$', r'-remove$',
+            r'_delete$', r'_suppression$', r'_supprimer$', r'_remove$',
+            r'delete$', r'suppression$', r'supprimer$'
+        ],
+        # Formulaire peut être create ou update selon le contexte
+        'formulaire': [
+            r'-formulaire$', r'_formulaire$', r'formulaire$',
+            r'-form$', r'_form$', r'form$'
+        ]
+    }
+
+    # Patterns d'URL pour détecter les paramètres
+    URL_PARAM_PATTERNS = [
+        (r'<int:pk>', 'pk'),
+        (r'<pk>', 'pk'),
+        (r'<int:id>', 'id'),
+        (r'<id>', 'id'),
+        (r'<slug:slug>', 'slug'),
+    ]
+
+    def __init__(self):
+        self.apps_prefix = lucy_assist_settings.PROJECT_APPS_PREFIX or ''
+
+    def discover_crud_views(self) -> Dict:
+        """
+        Découvre toutes les vues CRUD du projet.
+
+        Returns:
+            Dict avec le mapping modèle -> actions -> infos vue
+        """
+        LogUtils.info("[ViewDiscovery] Début de la découverte des vues CRUD")
+
+        crud_mapping = {}
+        resolver = get_resolver()
+
+        # Parcourir tous les URL patterns
+        self._scan_url_patterns(resolver.url_patterns, '', '', crud_mapping)
+
+        LogUtils.info(f"[ViewDiscovery] {len(crud_mapping)} modèles découverts")
+        for model, actions in crud_mapping.items():
+            LogUtils.info(f"[ViewDiscovery] {model}: {list(actions.keys())}")
+
+        return crud_mapping
+
+    def _scan_url_patterns(
+        self,
+        patterns: List,
+        namespace: str,
+        url_prefix: str,
+        crud_mapping: Dict
+    ):
+        """
+        Parcourt récursivement les URL patterns.
+        """
+        for pattern in patterns:
+            if isinstance(pattern, URLResolver):
+                # C'est un include() - descendre récursivement
+                new_namespace = pattern.namespace
+                if namespace and new_namespace:
+                    new_namespace = f"{namespace}:{new_namespace}"
+                elif namespace:
+                    new_namespace = namespace
+
+                # Construire le préfixe URL
+                pattern_str = self._get_pattern_string(pattern.pattern)
+                new_url_prefix = url_prefix + pattern_str
+
+                # Filtrer par préfixe d'apps si configuré
+                app_name = getattr(pattern, 'app_name', '') or ''
+                if self.apps_prefix:
+                    # Vérifier si c'est une app du projet
+                    if app_name and not app_name.startswith(self.apps_prefix.rstrip('.')):
+                        # Permettre aussi les apps dont le namespace correspond
+                        if new_namespace and not any(
+                            new_namespace.startswith(prefix)
+                            for prefix in ['admin', 'lucy_assist']
+                        ):
+                            pass  # Continuer l'exploration
+                        else:
+                            continue
+
+                self._scan_url_patterns(
+                    pattern.url_patterns,
+                    new_namespace or '',
+                    new_url_prefix,
+                    crud_mapping
+                )
+
+            elif isinstance(pattern, URLPattern):
+                # C'est une vue finale
+                self._process_url_pattern(
+                    pattern,
+                    namespace,
+                    url_prefix,
+                    crud_mapping
+                )
+
+    def _process_url_pattern(
+        self,
+        pattern: URLPattern,
+        namespace: str,
+        url_prefix: str,
+        crud_mapping: Dict
+    ):
+        """
+        Analyse un URL pattern pour détecter s'il s'agit d'une vue CRUD.
+        """
+        url_name = pattern.name
+        if not url_name:
+            return
+
+        # Construire l'URL complète
+        pattern_str = self._get_pattern_string(pattern.pattern)
+        full_url = '/' + url_prefix + pattern_str
+        full_url = re.sub(r'/+', '/', full_url)  # Normaliser les slashes
+
+        # Construire le nom complet de la vue
+        full_name = f"{namespace}:{url_name}" if namespace else url_name
+
+        # Détecter le modèle et l'action depuis le nom de l'URL
+        model_name, action = self._detect_model_and_action(url_name)
+
+        if not model_name or not action:
+            return
+
+        # Détecter si l'URL nécessite un paramètre (pk, id, etc.)
+        requires_pk = self._url_requires_pk(full_url)
+
+        # Déterminer la méthode HTTP
+        http_method = self._detect_http_method(pattern, action)
+
+        # Ajouter au mapping
+        model_lower = model_name.lower()
+        if model_lower not in crud_mapping:
+            crud_mapping[model_lower] = {}
+
+        # Les vues "formulaire" gèrent généralement create ET update
+        if action == 'formulaire':
+            crud_mapping[model_lower]['create'] = {
+                'url_name': full_name,
+                'url': full_url,
+                'method': 'POST',
+                'requires_pk': False
+            }
+            crud_mapping[model_lower]['update'] = {
+                'url_name': full_name,
+                'url': full_url,
+                'method': 'POST',
+                'requires_pk': True  # pk passé en POST ou GET
+            }
+            return
+
+        # Pour les autres actions create/update
+        if action == 'create' and requires_pk:
+            # C'est probablement une vue qui gère create et update
+            action = 'update'
+
+        crud_mapping[model_lower][action] = {
+            'url_name': full_name,
+            'url': full_url,
+            'method': http_method,
+            'requires_pk': requires_pk
+        }
+
+    def _detect_model_and_action(self, url_name: str) -> Tuple[Optional[str], Optional[str]]:
+        """
+        Détecte le nom du modèle et l'action CRUD depuis le nom de l'URL.
+
+        Args:
+            url_name: Nom de l'URL (ex: 'client-list', 'reservation-formulaire', 'client-b2b-gestion')
+
+        Returns:
+            Tuple (model_name, action) ou (None, None)
+        """
+        url_name_lower = url_name.lower()
+
+        # Chercher l'action dans le nom
+        detected_action = None
+        matched_pattern = None
+
+        for action, patterns in self.CRUD_PATTERNS.items():
+            for pattern in patterns:
+                if re.search(pattern, url_name_lower):
+                    detected_action = action
+                    matched_pattern = pattern
+                    break
+            if detected_action:
+                break
+
+        if not detected_action:
+            return None, None
+
+        # Extraire le nom du modèle en retirant le pattern d'action trouvé
+        model_name = re.sub(matched_pattern, '', url_name_lower)
+
+        # Nettoyer le nom du modèle
+        model_name = model_name.strip('-_')
+
+        # Convertir les tirets en underscores pour la cohérence
+        # mais garder aussi la version avec tirets pour le mapping
+        model_name_normalized = model_name.replace('-', '_')
+
+        if not model_name:
+            return None, None
+
+        # Retourner la version normalisée (avec underscores)
+        return model_name_normalized, detected_action
+
+    def _get_pattern_string(self, pattern) -> str:
+        """
+        Extrait la chaîne de pattern depuis un RoutePattern ou RegexPattern.
+        """
+        if hasattr(pattern, '_route'):
+            return pattern._route
+        elif hasattr(pattern, '_regex'):
+            # Convertir le regex en quelque chose de lisible
+            regex = pattern._regex
+            # Simplifier les captures
+            regex = re.sub(r'\(\?P<(\w+)>[^)]+\)', r'<\1>', regex)
+            regex = regex.strip('^$')
+            return regex
+        return ''
+
+    def _url_requires_pk(self, url: str) -> bool:
+        """
+        Vérifie si l'URL nécessite un paramètre pk/id.
+        """
+        pk_patterns = ['<pk>', '<int:pk>', '<id>', '<int:id>', '<slug>']
+        return any(p in url for p in pk_patterns)
+
+    def _detect_http_method(self, pattern: URLPattern, action: str) -> str:
+        """
+        Détecte la méthode HTTP appropriée pour une action.
+        """
+        # Pour les vues basées sur des classes, on peut essayer de détecter
+        # les méthodes supportées, mais par défaut on utilise les conventions
+
+        method_map = {
+            'list': 'GET',
+            'detail': 'GET',
+            'create': 'POST',
+            'update': 'POST',  # Souvent POST dans Django (pas PUT)
+            'delete': 'POST',  # Souvent POST dans Django (pas DELETE)
+        }
+
+        return method_map.get(action, 'GET')
+
+    def get_view_info(self, model_name: str, action: str) -> Optional[Dict]:
+        """
+        Récupère les informations d'une vue pour un modèle et une action.
+
+        Args:
+            model_name: Nom du modèle
+            action: Action CRUD ('list', 'create', 'detail', 'update', 'delete')
+
+        Returns:
+            Dict avec 'url_name', 'url', 'method', 'requires_pk' ou None
+        """
+        from lucy_assist.models import ConfigurationLucyAssist
+        config = ConfigurationLucyAssist.get_config()
+
+        if not config.crud_views_mapping:
+            config.refresh_crud_views_mapping()
+
+        model_lower = model_name.lower()
+
+        # Essayer plusieurs variations du nom de modèle
+        variations = [
+            model_lower,
+            model_lower.replace('_', '-'),  # client_b2b -> client-b2b
+            model_lower.replace('-', '_'),  # client-b2b -> client_b2b
+            model_lower.replace('_', ''),   # client_b2b -> clientb2b
+        ]
+
+        for variant in variations:
+            model_views = config.crud_views_mapping.get(variant, {})
+            if model_views and action in model_views:
+                return model_views.get(action)
+
+        return None
+
+    def get_all_discovered_models(self) -> List[str]:
+        """
+        Retourne la liste de tous les modèles découverts avec des vues CRUD.
+
+        Returns:
+            Liste des noms de modèles
+        """
+        from lucy_assist.models import ConfigurationLucyAssist
+        config = ConfigurationLucyAssist.get_config()
+
+        if not config.crud_views_mapping:
+            config.refresh_crud_views_mapping()
+
+        return list(config.crud_views_mapping.keys())