django-lucy-assist 1.2.3__py3-none-any.whl → 1.2.4__py3-none-any.whl

lucy_assist/services/context_service.py

@@ -452,3 +452,237 @@ class ContextService:
 
         except Exception:
             return None
+
+    def get_page_help(self, url_path: str) -> Dict:
+        """
+        Retourne une aide contextuelle enrichie pour la page actuelle.
+
+        Args:
+            url_path: URL de la page
+
+        Returns:
+            Dict avec aide, actions suggerees, liens utiles
+        """
+        context = self.get_page_context(url_path)
+        action = context.get('action')
+        model_name = context.get('model_name', 'element')
+        app_name = context.get('app_name', '')
+
+        help_info = {
+            'page_type': action,
+            'current_model': model_name,
+            'help_message': '',
+            'suggested_actions': [],
+            'useful_links': [],
+            'tips': []
+        }
+
+        # Generer les URLs utiles
+        from django.urls import reverse
+        model_lower = model_name.lower() if model_name else ''
+        app_simple = app_name.split(':')[-1] if app_name else ''
+
+        def try_reverse(pattern, **kwargs):
+            try:
+                return reverse(pattern, kwargs=kwargs) if kwargs else reverse(pattern)
+            except Exception:
+                return None
+
+        # Aide selon le type de page
+        if action == 'list':
+            help_info['help_message'] = f"Vous consultez la liste des {model_name}s."
+            help_info['suggested_actions'] = [
+                "Rechercher un element specifique",
+                "Filtrer la liste",
+                "Creer un nouvel element"
+            ]
+            help_info['tips'] = [
+                "Utilisez la barre de recherche pour trouver rapidement",
+                "Cliquez sur une ligne pour voir les details"
+            ]
+            # Lien creation
+            create_url = try_reverse(f'{app_simple}:{model_lower}-form')
+            if create_url:
+                help_info['useful_links'].append({
+                    'label': f'Creer un nouveau {model_name}',
+                    'url': create_url
+                })
+
+        elif action == 'create_or_edit':
+            if context.get('object_id'):
+                help_info['help_message'] = f"Vous modifiez un {model_name} existant."
+                help_info['suggested_actions'] = [
+                    "Modifier les informations",
+                    "Enregistrer les modifications",
+                    "Annuler et revenir a la liste"
+                ]
+            else:
+                help_info['help_message'] = f"Vous creez un nouveau {model_name}."
+                help_info['suggested_actions'] = [
+                    "Remplir les champs obligatoires",
+                    "Enregistrer le nouvel element"
+                ]
+            help_info['tips'] = [
+                "Les champs marques * sont obligatoires",
+                "Verifiez les informations avant d'enregistrer"
+            ]
+            # Lien liste
+            list_url = try_reverse(f'{app_simple}:{model_lower}-list')
+            if list_url:
+                help_info['useful_links'].append({
+                    'label': f'Retour a la liste des {model_name}s',
+                    'url': list_url
+                })
+
+        elif action == 'detail':
+            help_info['help_message'] = f"Vous consultez les details d'un {model_name}."
+            help_info['suggested_actions'] = [
+                "Modifier cet element",
+                "Supprimer cet element",
+                "Voir les elements lies"
+            ]
+            object_id = context.get('object_id')
+            if object_id:
+                edit_url = try_reverse(f'{app_simple}:{model_lower}-form', pk=object_id)
+                if edit_url:
+                    help_info['useful_links'].append({
+                        'label': 'Modifier',
+                        'url': edit_url
+                    })
+            list_url = try_reverse(f'{app_simple}:{model_lower}-list')
+            if list_url:
+                help_info['useful_links'].append({
+                    'label': f'Liste des {model_name}s',
+                    'url': list_url
+                })
+
+        elif action == 'delete':
+            help_info['help_message'] = f"Attention : vous allez supprimer ce {model_name}."
+            help_info['suggested_actions'] = [
+                "Confirmer la suppression",
+                "Annuler et revenir"
+            ]
+            help_info['tips'] = [
+                "Cette action est irreversible",
+                "Verifiez les elements lies qui seront aussi supprimes"
+            ]
+
+        else:
+            help_info['help_message'] = "Comment puis-je vous aider sur cette page ?"
+            help_info['suggested_actions'] = [
+                "Poser une question",
+                "Rechercher un element",
+                "Signaler un probleme"
+            ]
+
+        return help_info
+
+    def get_relevant_models(self, url_path: str) -> List[Dict]:
+        """
+        Retourne uniquement les modeles pertinents pour la page actuelle.
+        Optimise l'utilisation des tokens.
+
+        Args:
+            url_path: URL de la page
+
+        Returns:
+            Liste des modeles pertinents avec leurs champs
+        """
+        context = self.get_page_context(url_path)
+        app_name = context.get('app_name', '')
+        model_name = context.get('model_name')
+
+        relevant_models = []
+        apps_prefix = lucy_assist_settings.PROJECT_APPS_PREFIX
+        app_simple = app_name.split(':')[-1] if app_name else ''
+
+        # 1. Toujours inclure le modele de la page actuelle en premier
+        if model_name:
+            model_info = self._get_model_info(app_simple, model_name)
+            if model_info:
+                model_info['is_current'] = True
+                relevant_models.append(model_info)
+
+        # 2. Ajouter les modeles de la meme app (limiter a 5)
+        if app_simple:
+            try:
+                app_config = apps.get_app_config(app_simple)
+                for model in list(app_config.get_models())[:5]:
+                    if model.__name__ != model_name:
+                        model_info = self._get_model_info(app_simple, model.__name__)
+                        if model_info:
+                            model_info['is_current'] = False
+                            relevant_models.append(model_info)
+            except LookupError:
+                pass
+
+        # 3. Si moins de 3 modeles, ajouter les modeles principaux du projet
+        if len(relevant_models) < 3:
+            for app_config in apps.get_app_configs():
+                if apps_prefix and not app_config.name.startswith(apps_prefix):
+                    continue
+                if app_config.name.startswith('django.') or app_config.name == 'lucy_assist':
+                    continue
+                if app_config.label == app_simple:
+                    continue
+
+                for model in list(app_config.get_models())[:2]:
+                    if len(relevant_models) >= 8:
+                        break
+                    model_info = self._get_model_info(app_config.label, model.__name__)
+                    if model_info:
+                        model_info['is_current'] = False
+                        relevant_models.append(model_info)
+
+                if len(relevant_models) >= 8:
+                    break
+
+        return relevant_models
+
+    def _get_model_info(self, app_label: str, model_name: str) -> Optional[Dict]:
+        """Retourne les informations d'un modele."""
+        try:
+            model = apps.get_model(app_label, model_name)
+            fields = []
+            for field in model._meta.get_fields():
+                if hasattr(field, 'name') and not field.name.startswith('_'):
+                    if hasattr(field, 'auto_created') and field.auto_created:
+                        continue
+                    if field.name in ('id', 'pk', 'created_at', 'updated_at'):
+                        continue
+                    fields.append(field.name)
+
+            return {
+                'app': app_label,
+                'name': model_name,
+                'name_lower': model_name.lower(),
+                'fields': fields[:8],
+                'verbose_name': str(model._meta.verbose_name) if hasattr(model._meta, 'verbose_name') else model_name
+            }
+        except LookupError:
+            return None
+
+    def get_all_model_names(self) -> List[str]:
+        """
+        Retourne la liste de TOUS les noms de modeles du projet.
+        Utilise pour informer Lucy de ce qui existe vs ce qui n'existe pas.
+
+        Returns:
+            Liste des noms de modeles (ex: ['Client', 'Reservation', 'Facture'])
+        """
+        model_names = []
+        apps_prefix = lucy_assist_settings.PROJECT_APPS_PREFIX
+
+        for app_config in apps.get_app_configs():
+            # Filtrer les apps si un préfixe est configuré
+            if apps_prefix and not app_config.name.startswith(apps_prefix):
+                continue
+
+            # Ignorer les apps Django internes et lucy_assist
+            if app_config.name.startswith('django.') or app_config.name == 'lucy_assist':
+                continue
+
+            for model in app_config.get_models():
+                model_names.append(model.__name__)
+
+        return sorted(set(model_names))

lucy_assist/services/crud_service.py

@@ -160,6 +160,8 @@ class CRUDService:
         """
         Appelle une vue du projet via RequestFactory.
 
+        Utilise la découverte dynamique des vues (cache mémoire 5 min).
+
         Args:
             model_name: Nom du modèle
             action: Action CRUD ('create', 'update', 'delete', 'list', 'detail')
@@ -169,13 +171,10 @@ class CRUDService:
         Returns:
             Dict avec 'success', 'response', 'messages' ou None si pas de vue
         """
-        view_info = self.config.get_crud_view_for_model(model_name, action)
-
-        # Essayer aussi avec des variations du nom de modèle
-        if not view_info:
-            from lucy_assist.services.view_discovery_service import ViewDiscoveryService
-            service = ViewDiscoveryService()
-            view_info = service.get_view_info(model_name, action)
+        # Utiliser la découverte dynamique des vues (cache mémoire)
+        from lucy_assist.services.view_discovery_service import ViewDiscoveryService
+        service = ViewDiscoveryService()
+        view_info = service.get_view_info(model_name, action)
 
         if not view_info:
             LogUtils.info(f"[CRUD] Pas de vue trouvée pour {model_name}.{action}")
@@ -187,6 +186,36 @@ class CRUDService:
 
         LogUtils.info(f"[CRUD] Appel vue {url_name} ({method}) pour {model_name}.{action}")
 
+        # Vérifier que l'utilisateur est authentifié
+        if not self.user or not self.user.is_authenticated:
+            LogUtils.warning(f"[CRUD] Utilisateur non authentifié pour {model_name}.{action}")
+            return {
+                'success': False,
+                'error': "Vous devez être connecté pour effectuer cette action.",
+                'permission_denied': True,
+                'messages': []
+            }
+
+        # Vérifier les permissions Django standard (optionnel mais rapide)
+        action_to_perm = {
+            'create': 'add',
+            'update': 'change',
+            'delete': 'delete',
+            'detail': 'view',
+            'list': 'view',
+        }
+        perm_action = action_to_perm.get(action)
+        if perm_action and not self.user.is_superuser:
+            # Trouver l'app_label du modèle
+            model = self.get_model('', model_name)
+            if model:
+                app_label = model._meta.app_label
+                perm_codename = f"{app_label}.{perm_action}_{model_name.lower()}"
+                if not self.user.has_perm(perm_codename):
+                    LogUtils.warning(f"[CRUD] Permission Django manquante: {perm_codename}")
+                    # On ne bloque pas ici car la vue peut avoir des permissions custom
+                    # mais on log pour le debug
+
         try:
             # Construire l'URL
             if requires_pk and object_id:
@@ -226,21 +255,49 @@ class CRUDService:
                 self._cleanup_thread_local()
 
             # Analyser la réponse
-            success = response.status_code in [200, 201, 302]
+            redirect_url = response.get('Location', '') if response.status_code == 302 else ''
             messages = self._extract_messages(request)
 
-            # Détecter les erreurs dans la réponse
+            # Vérifier si c'est une redirection vers login (permission refusée)
+            is_permission_denied = False
+            if response.status_code == 302 and redirect_url:
+                login_patterns = ['/login', '/connexion', '/auth', 'accounts/login']
+                if any(pattern in redirect_url.lower() for pattern in login_patterns):
+                    is_permission_denied = True
+                    LogUtils.warning(f"[CRUD] Permission refusée - redirection vers {redirect_url}")
+
+            # Vérifier si c'est une erreur 403 (Forbidden)
+            if response.status_code == 403:
+                is_permission_denied = True
+                LogUtils.warning(f"[CRUD] Permission refusée - HTTP 403")
+
+            if is_permission_denied:
+                return {
+                    'success': False,
+                    'status_code': response.status_code,
+                    'error': "Vous n'avez pas les permissions nécessaires pour effectuer cette action.",
+                    'permission_denied': True,
+                    'messages': messages
+                }
+
+            # Déterminer le succès
+            success = response.status_code in [200, 201, 302]
+
+            # Détecter les erreurs dans la réponse HTML
             if hasattr(response, 'content'):
                 content = response.content.decode('utf-8', errors='replace')
                 # Chercher des indicateurs d'erreur dans le HTML
                 if 'class="error' in content or 'class="invalid' in content:
                     success = False
+                # Détecter les messages d'erreur de permission dans le contenu
+                if 'permission' in content.lower() and ('denied' in content.lower() or 'refusé' in content.lower()):
+                    success = False
 
             return {
                 'success': success,
                 'status_code': response.status_code,
                 'messages': messages,
-                'redirect_url': response.get('Location') if response.status_code == 302 else None
+                'redirect_url': redirect_url if response.status_code == 302 else None
             }
 
         except NoReverseMatch as e:
@@ -480,7 +537,16 @@ class CRUDService:
                     'via_view': True
                 }
 
-        # Fallback: création directe via le modèle
+        # Si CRUD_VIEWS_ONLY est activé, refuser l'opération
+        if lucy_assist_settings.get('CRUD_VIEWS_ONLY', True):
+            LogUtils.info(f"[CRUD] Aucune vue trouvée pour {model_name}.create et CRUD_VIEWS_ONLY=True")
+            return {
+                'success': False,
+                'errors': [f"Aucune vue de création trouvée pour {model_name}. L'opération CRUD n'est pas disponible pour ce modèle."],
+                'no_view_found': True
+            }
+
+        # Fallback: création directe via le modèle (si autorisé)
         LogUtils.info(f"[CRUD] Fallback création directe pour {model_name}")
         return self._create_object_direct(app_name, model_name, data)
 
@@ -594,7 +660,16 @@ class CRUDService:
                     'via_view': True
                 }
 
-        # Fallback: mise à jour directe via le modèle
+        # Si CRUD_VIEWS_ONLY est activé, refuser l'opération
+        if lucy_assist_settings.get('CRUD_VIEWS_ONLY', True):
+            LogUtils.info(f"[CRUD] Aucune vue trouvée pour {model_name}.update et CRUD_VIEWS_ONLY=True")
+            return {
+                'success': False,
+                'errors': [f"Aucune vue de modification trouvée pour {model_name}. L'opération CRUD n'est pas disponible pour ce modèle."],
+                'no_view_found': True
+            }
+
+        # Fallback: mise à jour directe via le modèle (si autorisé)
         LogUtils.info(f"[CRUD] Fallback mise à jour directe pour {model_name}")
         return self._update_object_direct(app_name, model_name, object_id, data)
 
@@ -715,7 +790,16 @@ class CRUDService:
                     'via_view': True
                 }
 
-        # Fallback: suppression directe via le modèle
+        # Si CRUD_VIEWS_ONLY est activé, refuser l'opération
+        if lucy_assist_settings.get('CRUD_VIEWS_ONLY', True):
+            LogUtils.info(f"[CRUD] Aucune vue trouvée pour {model_name}.delete et CRUD_VIEWS_ONLY=True")
+            return {
+                'success': False,
+                'errors': [f"Aucune vue de suppression trouvée pour {model_name}. L'opération CRUD n'est pas disponible pour ce modèle."],
+                'no_view_found': True
+            }
+
+        # Fallback: suppression directe via le modèle (si autorisé)
         LogUtils.info(f"[CRUD] Fallback suppression directe pour {model_name}")
         return self._delete_object_direct(app_name, model_name, object_id)
 

lucy_assist/services/gitlab_service.py

@@ -35,6 +35,26 @@ class GitLabService:
         """Construit l'URL de l'API."""
         return f"{self.base_url}/api/v4{endpoint}"
 
+    def get_default_branch(self) -> str:
+        """
+        Recupere la branche par defaut du projet.
+
+        Returns:
+            Nom de la branche par defaut ou 'main' si erreur
+        """
+        if not self.token or not self.project_id:
+            return 'main'
+
+        try:
+            url = self._api_url(f"/projects/{self.project_id}")
+            response = requests.get(url, headers=self.headers, timeout=10)
+            response.raise_for_status()
+            project_info = response.json()
+            return project_info.get('default_branch', 'main')
+        except requests.RequestException as e:
+            LogUtils.error(f"Erreur lors de la recuperation de la branche par defaut: {e}")
+            return 'main'
+
     def search_code(
             self,
             query: str,
@@ -76,14 +96,14 @@ class GitLabService:
     def get_file_content(
             self,
             file_path: str,
-            ref: str = 'main'
+            ref: str = None
     ) -> Optional[str]:
         """
-        Récupère le contenu d'un fichier.
+        Recupere le contenu d'un fichier.
 
         Args:
             file_path: Chemin du fichier dans le repo
-            ref: Branche ou tag
+            ref: Branche ou tag (None = branche par defaut)
 
         Returns:
             Contenu du fichier ou None
@@ -91,6 +111,10 @@ class GitLabService:
         if not self.token or not self.project_id:
             return None
 
+        # Utiliser la branche par defaut si non specifiee
+        if ref is None:
+            ref = self.get_default_branch()
+
         try:
             encoded_path = quote(file_path, safe='')
             url = self._api_url(
@@ -104,16 +128,16 @@ class GitLabService:
             return response.text
 
         except requests.RequestException as e:
-            LogUtils.error(f"Erreur lors de la récupération du fichier {file_path}: {e}")
+            LogUtils.error(f"Erreur lors de la recuperation du fichier {file_path}: {e}")
             return None
 
     def get_file_blame(
             self,
             file_path: str,
-            ref: str = 'main'
+            ref: str = None
     ) -> List[Dict]:
         """
-        Récupère le blame d'un fichier (qui a modifié quoi).
+        Recupere le blame d'un fichier (qui a modifie quoi).
 
         Returns:
             Liste des blocs de blame
@@ -121,6 +145,10 @@ class GitLabService:
         if not self.token or not self.project_id:
             return []
 
+        # Utiliser la branche par defaut si non specifiee
+        if ref is None:
+            ref = self.get_default_branch()
+
         try:
             encoded_path = quote(file_path, safe='')
             url = self._api_url(
@@ -218,6 +246,51 @@ class GitLabService:
 
         return result
 
+    def get_repository_tree(
+            self,
+            path: str = '',
+            ref: str = None,
+            recursive: bool = True,
+            per_page: int = 100
+    ) -> List[Dict]:
+        """
+        Liste les fichiers et dossiers du repository.
+
+        Args:
+            path: Chemin du dossier (vide = racine)
+            ref: Branche ou tag (None = branche par defaut)
+            recursive: Inclure les sous-dossiers
+            per_page: Nombre de resultats par page
+
+        Returns:
+            Liste des fichiers/dossiers avec 'name', 'path', 'type'
+        """
+        if not self.token or not self.project_id:
+            return []
+
+        # Utiliser la branche par defaut si non specifiee
+        if ref is None:
+            ref = self.get_default_branch()
+
+        try:
+            url = self._api_url(f"/projects/{self.project_id}/repository/tree")
+            params = {
+                'ref': ref,
+                'recursive': str(recursive).lower(),
+                'per_page': per_page
+            }
+            if path:
+                params['path'] = path
+
+            response = requests.get(url, headers=self.headers, params=params, timeout=15)
+            response.raise_for_status()
+
+            return response.json()
+
+        except requests.RequestException as e:
+            LogUtils.error(f"Erreur lors de la recuperation de l'arborescence: {e}")
+            return []
+
     def get_recent_commits(self, per_page: int = 10) -> List[Dict]:
         """
         Récupère les commits récents.

lucy_assist/services/mistral_service.py

@@ -60,6 +60,8 @@ class MistralService:
         Utilise le prompt stocke en base de donnees et le cache
         pour reduire la redondance des informations sur le projet.
         """
+        from lucy_assist.services.context_service import ContextService
+
         # Recuperer les permissions utilisateur (compressees)
         user_permissions = []
         if hasattr(user, 'get_all_permissions'):
@@ -69,25 +71,43 @@ class MistralService:
 
         # Recuperer le contexte projet optimise depuis le cache
         page_url = page_context.get('page_url', page_context.get('url', ''))
-        optimized_context = self.project_context_service.get_optimized_context(
-            page_url=page_url,
-            user_question=user_question
-        )
 
-        # Fusionner le contexte de page avec le contexte projet cache
+        # Utiliser ContextService pour obtenir les modeles pertinents (optimisation tokens)
+        context_service = ContextService(user)
+        relevant_models = context_service.get_relevant_models(page_url)
+
+        # Formater les modeles pertinents (avec details)
+        models_description = []
+        for model in relevant_models:
+            prefix = "[PAGE ACTUELLE] " if model.get('is_current') else ""
+            fields_str = ", ".join(model.get('fields', []))
+            models_description.append(
+                f"{prefix}{model['name']} ({model['name_lower']}): {fields_str}"
+            )
+
+        # Ajouter la liste complete de TOUS les modeles disponibles (juste les noms)
+        all_model_names = context_service.get_all_model_names()
+        if all_model_names:
+            models_description.append("")
+            models_description.append("Liste complete des modeles existants: " + ", ".join(all_model_names))
+
+        available_models = "\n".join(models_description) if models_description else "Aucun modele"
+
+        # Enrichir le contexte de page avec l'aide contextuelle
+        page_help = context_service.get_page_help(page_url)
         enriched_context = {
-            'page': page_context,
-            'projet': optimized_context.get('relevant_info', {}),
-            'cache_stats': optimized_context.get('stats', {})
+            'url': page_url,
+            'type_page': page_help.get('page_type'),
+            'modele_actuel': page_help.get('current_model'),
+            'aide': page_help.get('help_message'),
+            'actions_suggerees': page_help.get('suggested_actions', []),
+            'liens_utiles': page_help.get('useful_links', [])
         }
 
         # Recuperer la configuration avec le prompt systeme
         from lucy_assist.models import ConfigurationLucyAssist
         config = ConfigurationLucyAssist.get_config()
 
-        # Generer la description des modeles disponibles
-        available_models = config.get_available_models_description()
-
         # Construire le prompt depuis la configuration
         prompt = config.get_system_prompt(
             page_context=json.dumps(enriched_context, ensure_ascii=False, indent=2),