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

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),

lucy_assist/services/tool_executor_service.py

@@ -54,6 +54,9 @@ class ToolExecutorService:
             'get_form_fields': self._handle_get_form_fields,
             'navigate_to_page': self._handle_navigate_to_page,
             'analyze_bug': self._handle_analyze_bug,
+            'get_page_help': self._handle_get_page_help,
+            'search_code_gitlab': self._handle_search_code_gitlab,
+            'get_file_content_gitlab': self._handle_get_file_content_gitlab,
         }
 
         handler = handlers.get(tool_name)
@@ -371,6 +374,94 @@ class ToolExecutorService:
         }
 
 
+    def _handle_get_page_help(self, params: Dict) -> Dict:
+        """
+        Recupere l'aide contextuelle pour la page actuelle.
+        """
+        url_path = params.get('url_path', '')
+
+        if not url_path:
+            return {'error': 'url_path est requis'}
+
+        help_info = self.context_service.get_page_help(url_path)
+
+        return {
+            'success': True,
+            **help_info
+        }
+
+    def _handle_search_code_gitlab(self, params: Dict) -> Dict:
+        """
+        Recherche dans le code source du projet via GitLab.
+        """
+        query = params.get('query', '')
+        file_type = params.get('file_type', 'all')
+
+        if not query:
+            return {'error': 'query est requis'}
+
+        # Adapter la recherche selon le type de fichier
+        search_query = query
+        if file_type != 'all':
+            # Ajouter un filtre de chemin pour cibler le type de fichier
+            search_query = f"{query} path:{file_type}"
+
+        results = self.gitlab_service.search_code(search_query, per_page=10)
+
+        if not results:
+            return {
+                'success': True,
+                'count': 0,
+                'message': f'Aucun resultat trouve pour "{query}"',
+                'results': []
+            }
+
+        # Formater les resultats
+        formatted_results = []
+        for result in results[:10]:
+            formatted_results.append({
+                'file': result.get('filename', ''),
+                'content_preview': result.get('data', '')[:500],
+                'ref': result.get('ref', '')
+            })
+
+        return {
+            'success': True,
+            'count': len(formatted_results),
+            'query': query,
+            'results': formatted_results
+        }
+
+    def _handle_get_file_content_gitlab(self, params: Dict) -> Dict:
+        """
+        Recupere le contenu complet d'un fichier depuis GitLab.
+        """
+        file_path = params.get('file_path', '')
+
+        if not file_path:
+            return {'error': 'file_path est requis'}
+
+        content = self.gitlab_service.get_file_content(file_path)
+
+        if content is None:
+            return {
+                'success': False,
+                'error': f'Fichier non trouve: {file_path}'
+            }
+
+        # Limiter la taille du contenu retourne
+        max_content_size = 10000
+        truncated = len(content) > max_content_size
+
+        return {
+            'success': True,
+            'file_path': file_path,
+            'content': content[:max_content_size],
+            'truncated': truncated,
+            'total_size': len(content)
+        }
+
+
 def create_tool_executor(user):
     """
     Factory function pour créer un callable d'exécution de tools.

lucy_assist/services/tools_definition.py

@@ -274,6 +274,71 @@ LUCY_ASSIST_TOOLS = [
                 "required": ["user_description"]
             }
         }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "get_page_help",
+            "description": """Recupere l'aide contextuelle pour la page actuelle.
+            Utilise ce tool pour obtenir des informations sur ce que l'utilisateur peut faire sur la page.
+            Retourne les actions suggerees, liens utiles et conseils.""",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "url_path": {
+                        "type": "string",
+                        "description": "URL de la page actuelle (disponible dans le contexte)"
+                    }
+                },
+                "required": ["url_path"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "search_code_gitlab",
+            "description": """USAGE INTERNE - Recherche dans le code source pour comprendre le fonctionnement.
+            Utilise ce tool pour comprendre comment fonctionne une fonctionnalite.
+            IMPORTANT: Les resultats sont pour TON usage interne uniquement.
+            Ne JAMAIS montrer les chemins de fichiers ou le code a l'utilisateur.
+            Utilise ces informations pour repondre en termes simples avec des liens vers les pages.""",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "Terme de recherche (nom de classe, fonction, variable, texte)"
+                    },
+                    "file_type": {
+                        "type": "string",
+                        "enum": ["models", "views", "urls", "forms", "admin", "all"],
+                        "description": "Type de fichier a rechercher (defaut: all)"
+                    }
+                },
+                "required": ["query"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "get_file_content_gitlab",
+            "description": """USAGE INTERNE - Recupere le contenu d'un fichier pour comprendre le fonctionnement.
+            IMPORTANT: Les resultats sont pour TON usage interne uniquement.
+            Ne JAMAIS montrer le code source ou les chemins de fichiers a l'utilisateur.
+            Utilise ces informations pour repondre en termes simples avec des liens vers les pages.""",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "file_path": {
+                        "type": "string",
+                        "description": "Chemin du fichier dans le repository"
+                    }
+                },
+                "required": ["file_path"]
+            }
+        }
     }
 ]
 

lucy_assist/services/view_discovery_service.py

@@ -16,8 +16,16 @@ from lucy_assist.conf import lucy_assist_settings
 class ViewDiscoveryService:
     """
     Service pour découvrir automatiquement les vues CRUD d'un projet Django.
+
+    La découverte est mise en cache en mémoire pour éviter de scanner
+    les URLs à chaque requête.
     """
 
+    # Cache en mémoire pour les vues découvertes (partagé entre instances)
+    _views_cache = None
+    _cache_timestamp = None
+    CACHE_TTL = 300  # 5 minutes
+
     # Patterns de nommage courants pour les vues CRUD
     # L'ordre est important : les patterns plus spécifiques doivent être en premier
     CRUD_PATTERNS = {
@@ -65,6 +73,35 @@ class ViewDiscoveryService:
     def __init__(self):
         self.apps_prefix = lucy_assist_settings.PROJECT_APPS_PREFIX or ''
 
+    @classmethod
+    def get_cached_views(cls) -> Dict:
+        """
+        Retourne les vues CRUD depuis le cache mémoire.
+        Redécouvre automatiquement si le cache est expiré.
+        """
+        import time
+
+        now = time.time()
+
+        # Vérifier si le cache est valide
+        if (cls._views_cache is not None and
+            cls._cache_timestamp is not None and
+            now - cls._cache_timestamp < cls.CACHE_TTL):
+            return cls._views_cache
+
+        # Redécouvrir les vues
+        service = cls()
+        cls._views_cache = service.discover_crud_views()
+        cls._cache_timestamp = now
+
+        return cls._views_cache
+
+    @classmethod
+    def invalidate_cache(cls):
+        """Force la redécouverte des vues au prochain appel."""
+        cls._views_cache = None
+        cls._cache_timestamp = None
+
     def discover_crud_views(self) -> Dict:
         """
         Découvre toutes les vues CRUD du projet.
@@ -293,6 +330,9 @@ class ViewDiscoveryService:
         """
         Récupère les informations d'une vue pour un modèle et une action.
 
+        Utilise le cache mémoire pour éviter de scanner les URLs à chaque requête.
+        Le cache est automatiquement rafraîchi après CACHE_TTL secondes.
+
         Args:
             model_name: Nom du modèle
             action: Action CRUD ('list', 'create', 'detail', 'update', 'delete')
@@ -300,11 +340,8 @@ class ViewDiscoveryService:
         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()
+        # Utiliser le cache mémoire (découverte dynamique)
+        crud_views_mapping = self.get_cached_views()
 
         model_lower = model_name.lower()
 
@@ -317,10 +354,12 @@ class ViewDiscoveryService:
         ]
 
         for variant in variations:
-            model_views = config.crud_views_mapping.get(variant, {})
+            model_views = crud_views_mapping.get(variant, {})
             if model_views and action in model_views:
+                LogUtils.info(f"[ViewDiscovery] Vue trouvée: {variant}.{action} -> {model_views[action].get('url_name')}")
                 return model_views.get(action)
 
+        LogUtils.info(f"[ViewDiscovery] Aucune vue trouvée pour {model_name}.{action}")
         return None
 
     def get_all_discovered_models(self) -> List[str]:
@@ -330,10 +369,5 @@ class ViewDiscoveryService:
         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())
+        crud_views_mapping = self.get_cached_views()
+        return list(crud_views_mapping.keys())