django-lucy-assist 0.1.0__py3-none-any.whl

lucy_assist/services/bug_notification_service.py

@@ -0,0 +1,183 @@
+"""
+Service de notification automatique des bugs détectés.
+
+Ce service est appelé quand Lucy détecte un bug lors de l'analyse du code
+via GitLab. Il envoie automatiquement un email au gestionnaire de projet.
+"""
+import requests
+from typing import Dict, Any, Optional
+
+from django.conf import settings
+from django.core.mail import send_mail
+from django.utils import timezone
+
+from lucy_assist.utils.log_utils import LogUtils
+
+
+class BugNotificationService:
+    """Service pour notifier automatiquement quand un bug est détecté."""
+
+    # Email par défaut si aucun collaborateur associé
+    EMAIL_FALLBACK = 'maxence@revolucy.fr'
+
+    def __init__(self, user=None):
+        self.user = user
+
+    def get_collaborateur_email(self) -> str:
+        """
+        Récupère l'email du collaborateur associé via l'API Lucy CRM.
+        Utilise le SIREN du client configuré dans les settings.
+        Retourne l'email par défaut si non trouvé.
+        """
+        try:
+            # Récupérer le SIREN depuis les settings
+            siren_client = getattr(settings, 'SIREN_CLIENT', None)
+            if not siren_client:
+                LogUtils.warning("SIREN_CLIENT non configuré, utilisation de l'email par défaut")
+                return self.EMAIL_FALLBACK
+
+            # Appel à l'API Lucy CRM
+            url = f"https://app.lucy-crm.fr/api/credit-client/{siren_client}"
+            response = requests.get(url, timeout=10)
+
+            if response.status_code == 200:
+                data = response.json()
+                collaborateur_email = data.get('collaborateur_associe')
+
+                if collaborateur_email:
+                    LogUtils.info(f"Collaborateur associé trouvé: {collaborateur_email}")
+                    return collaborateur_email
+                else:
+                    LogUtils.info("Aucun collaborateur associé, utilisation de l'email par défaut")
+                    return self.EMAIL_FALLBACK
+            else:
+                LogUtils.warning(f"API Lucy CRM a retourné le status {response.status_code}")
+                return self.EMAIL_FALLBACK
+
+        except requests.RequestException as e:
+            LogUtils.error(f"Erreur appel API Lucy CRM: {str(e)}")
+            return self.EMAIL_FALLBACK
+        except Exception as e:
+            LogUtils.error(f"Erreur récupération collaborateur: {str(e)}")
+            return self.EMAIL_FALLBACK
+
+    def notify_bug_detected(
+        self,
+        bug_analysis: Dict[str, Any],
+        user_description: str,
+        error_message: str = "",
+        code_context: str = "",
+        file_path: str = "",
+        page_url: str = ""
+    ) -> Dict[str, Any]:
+        """
+        Envoie une notification email quand un bug est détecté.
+
+        Args:
+            bug_analysis: Résultat de l'analyse du bug (is_bug, analysis, recommendation, severity)
+            user_description: Description du problème par l'utilisateur
+            error_message: Message d'erreur signalé (optionnel)
+            code_context: Code source analysé (optionnel)
+            file_path: Chemin du fichier contenant le bug (optionnel)
+            page_url: URL de la page où le bug a été signalé (optionnel)
+
+        Returns:
+            Dict avec 'success' et 'message'
+        """
+        # Vérifier si c'est bien un bug
+        if not bug_analysis.get('is_bug', False):
+            return {
+                'success': False,
+                'message': "Ce n'est pas un bug, notification non envoyée.",
+                'notified': False
+            }
+
+        try:
+            destinataire = self.get_collaborateur_email()
+
+            # Informations utilisateur
+            user_name = "Utilisateur"
+            user_email = "Non disponible"
+            if self.user:
+                user_name = self.user.get_full_name() if hasattr(self.user, 'get_full_name') else str(self.user)
+                user_email = self.user.email if hasattr(self.user, 'email') else 'Non disponible'
+
+            # Déterminer la sévérité
+            severity = bug_analysis.get('severity', 'medium')
+            severity_label = {
+                'low': '🟡 Faible',
+                'medium': '🟠 Moyenne',
+                'high': '🔴 Élevée'
+            }.get(severity, '🟠 Moyenne')
+
+            sujet = f"[Lucy Assist] 🐛 Bug détecté - Sévérité {severity_label}"
+
+            message_email = f"""
+Lucy Assist a détecté un bug dans le code.
+
+================================================================================
+📊 ANALYSE DU BUG
+================================================================================
+Sévérité        : {severity_label}
+Fichier         : {file_path or 'Non identifié'}
+Page            : {page_url or 'Non spécifiée'}
+
+📋 Analyse      :
+{bug_analysis.get('analysis', 'Non disponible')}
+
+💡 Recommandation :
+{bug_analysis.get('recommendation', 'Non disponible')}
+
+================================================================================
+👤 INFORMATIONS UTILISATEUR
+================================================================================
+Utilisateur     : {user_name}
+Email           : {user_email}
+Date            : {timezone.now().strftime('%d/%m/%Y à %H:%M')}
+
+📝 Description du problème par l'utilisateur :
+{user_description or 'Non fournie'}
+
+⚠️ Message d'erreur signalé :
+{error_message or 'Aucun'}
+
+================================================================================
+💻 CODE SOURCE ANALYSÉ
+================================================================================
+{code_context[:2000] if code_context else 'Non disponible'}
+{('...[tronqué]' if code_context and len(code_context) > 2000 else '')}
+
+================================================================================
+Cette notification a été envoyée automatiquement par Lucy Assist
+suite à la détection d'un bug lors de l'analyse du code via GitLab.
+================================================================================
+"""
+
+            send_mail(
+                subject=sujet,
+                message=message_email,
+                from_email=settings.DEFAULT_FROM_EMAIL,
+                recipient_list=[destinataire],
+                fail_silently=False
+            )
+
+            LogUtils.info(
+                f"Notification bug envoyée à {destinataire} - "
+                f"Sévérité: {severity}, Fichier: {file_path or 'inconnu'}"
+            )
+
+            return {
+                'success': True,
+                'message': f"Bug détecté et signalé à Revolucy ({destinataire})",
+                'notified': True,
+                'recipient': destinataire,
+                'severity': severity
+            }
+
+        except Exception as e:
+            LogUtils.error(f"Erreur envoi notification bug: {str(e)}")
+            return {
+                'success': False,
+                'message': f"Erreur lors de l'envoi de la notification: {str(e)}",
+                'notified': False
+            }

lucy_assist/services/claude_service.py

@@ -0,0 +1,417 @@
+"""
+Service d'intégration avec Claude API (Anthropic).
+
+Optimisations tokens:
+- Cache du contexte projet via ProjectContextService
+- Résumé des conversations longues
+- Compression intelligente du contexte
+
+Tools CRUD:
+- Claude peut exécuter des actions CRUD via les tools
+- Les tools sont exécutés côté serveur avec les permissions de l'utilisateur
+"""
+import json
+from typing import Generator, List, Dict, Any
+
+import anthropic
+
+from lucy_assist.utils.log_utils import LogUtils
+from lucy_assist.constantes import LucyAssistConstantes
+from lucy_assist.services.tools_definition import LUCY_ASSIST_TOOLS
+from lucy_assist.conf import lucy_assist_settings
+
+
+class ClaudeService:
+    """Service pour interagir avec l'API Claude d'Anthropic."""
+
+    MAX_TOKENS = 4096
+
+    # Seuils pour l'optimisation
+    MAX_MESSAGES_BEFORE_SUMMARY = 10  # Résumer après 10 messages
+    MAX_CONTEXT_TOKENS = 2000  # Limiter le contexte à 2000 tokens estimés
+
+    def __init__(self):
+        self.api_key = lucy_assist_settings.CLAUDE_API_KEY
+        if not self.api_key:
+            raise ValueError("CLAUDE_API_KEY non configurée dans les settings")
+
+        self.client = anthropic.Anthropic(api_key=self.api_key)
+        self._project_context_service = None
+        self._tools = LUCY_ASSIST_TOOLS
+        self._model = lucy_assist_settings.CLAUDE_MODEL
+
+    @property
+    def project_context_service(self):
+        """Lazy loading du service de contexte projet."""
+        if self._project_context_service is None:
+            from lucy_assist.services.project_context_service import ProjectContextService
+            self._project_context_service = ProjectContextService()
+        return self._project_context_service
+
+    def _build_system_prompt(
+        self,
+        page_context: Dict,
+        user,
+        user_question: str = ""
+    ) -> str:
+        """
+        Construit le prompt système avec le contexte optimisé.
+
+        Utilise le cache pour réduire la redondance des informations
+        sur le projet.
+        """
+        # Récupérer les permissions utilisateur (compressées)
+        user_permissions = []
+        if hasattr(user, 'get_all_permissions'):
+            # Ne garder que les permissions pertinentes (sans préfixe d'app commun)
+            all_perms = list(user.get_all_permissions())
+            user_permissions = [p.split('.')[-1] for p in all_perms[:15]]
+
+        # Récupérer le contexte projet optimisé 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 caché
+        enriched_context = {
+            'page': page_context,
+            'projet': optimized_context.get('relevant_info', {}),
+            'cache_stats': optimized_context.get('stats', {})
+        }
+
+        # Construire le prompt avec contexte compact
+        prompt = LucyAssistConstantes.SYSTEM_PROMPTS['default'].format(
+            page_context=json.dumps(enriched_context, ensure_ascii=False, indent=2),
+            user_permissions=', '.join(user_permissions)
+        )
+
+        return prompt
+
+    def _optimize_messages(self, messages: List) -> List[Dict]:
+        """
+        Optimise l'historique des messages pour réduire les tokens.
+
+        Pour les conversations longues, résume les anciens messages
+        au lieu de les envoyer en entier.
+        """
+        formatted = self._format_messages(messages)
+
+        if len(formatted) <= self.MAX_MESSAGES_BEFORE_SUMMARY:
+            return formatted
+
+        # Résumer la conversation
+        summary_data = self.project_context_service.summarize_conversation(
+            formatted,
+            max_tokens=500
+        )
+
+        if not summary_data:
+            return formatted
+
+        # Reconstruire les messages avec le résumé
+        optimized = []
+
+        # Ajouter les premiers messages
+        optimized.extend(summary_data['first_messages'])
+
+        # Ajouter le résumé comme message système
+        optimized.append({
+            'role': 'user',
+            'content': f"[Note: {summary_data['original_count'] - 4} messages résumés]\n{summary_data['summary']}"
+        })
+
+        # Ajouter les derniers messages
+        optimized.extend(summary_data['last_messages'])
+
+        LogUtils.info(
+            f"Conversation optimisée: {len(formatted)} -> {len(optimized)} messages, "
+            f"~{summary_data.get('tokens_saved_estimate', 0)} tokens économisés"
+        )
+
+        return optimized
+
+    def _format_messages(self, messages: List) -> List[Dict]:
+        """Formate les messages pour l'API Claude."""
+        formatted = []
+
+        for msg in messages:
+            role = "user" if msg.repondant == LucyAssistConstantes.Repondant.UTILISATEUR else "assistant"
+            formatted.append({
+                "role": role,
+                "content": msg.contenu
+            })
+
+        return formatted
+
+    def chat_completion_stream(
+        self,
+        messages: List,
+        page_context: Dict,
+        user,
+        tool_executor=None
+    ) -> Generator[Dict[str, Any], None, None]:
+        """
+        Génère une réponse en streaming avec support des tools.
+
+        Args:
+            messages: Liste des messages de la conversation
+            page_context: Contexte de la page courante
+            user: Utilisateur Django
+            tool_executor: Callable pour exécuter les tools (optionnel)
+
+        Yields:
+            Dict avec 'type' (content/tool_use/tool_result/usage/error) et les données associées
+        """
+        try:
+            # Extraire la question utilisateur du dernier message
+            user_question = ""
+            if messages:
+                last_msg = messages[-1] if hasattr(messages[-1], 'contenu') else messages[-1]
+                user_question = getattr(last_msg, 'contenu', '') if hasattr(last_msg, 'contenu') else str(last_msg)
+
+            system_prompt = self._build_system_prompt(page_context, user, user_question)
+
+            # Utiliser l'optimisation des messages pour les longues conversations
+            formatted_messages = self._optimize_messages(messages)
+
+            if not formatted_messages:
+                yield {'type': 'error', 'error': 'Aucun message à traiter'}
+                return
+
+            # Boucle pour gérer les appels de tools
+            current_messages = formatted_messages.copy()
+            max_tool_iterations = 5  # Limite de sécurité
+
+            for iteration in range(max_tool_iterations):
+                with self.client.messages.stream(
+                    model=self._model,
+                    max_tokens=self.MAX_TOKENS,
+                    system=system_prompt,
+                    messages=current_messages,
+                    tools=self._tools
+                ) as stream:
+                    response_text = ""
+                    tool_uses = []
+
+                    for text in stream.text_stream:
+                        response_text += text
+                        yield {'type': 'content', 'content': text}
+
+                    # Récupérer la réponse finale pour les tools
+                    response = stream.get_final_message()
+
+                    # Extraire les appels de tools
+                    for block in response.content:
+                        if block.type == "tool_use":
+                            tool_uses.append({
+                                'id': block.id,
+                                'name': block.name,
+                                'input': block.input
+                            })
+
+                    # Si pas de tool_use, on a fini
+                    if not tool_uses or response.stop_reason != "tool_use":
+                        if response.usage:
+                            total_tokens = response.usage.input_tokens + response.usage.output_tokens
+                            yield {
+                                'type': 'usage',
+                                'input_tokens': response.usage.input_tokens,
+                                'output_tokens': response.usage.output_tokens,
+                                'total_tokens': total_tokens
+                            }
+                        return
+
+                    # Exécuter les tools
+                    tool_results = []
+                    for tool_use in tool_uses:
+                        yield {
+                            'type': 'tool_use',
+                            'tool_name': tool_use['name'],
+                            'tool_input': tool_use['input']
+                        }
+
+                        # Exécuter le tool si un executor est fourni
+                        if tool_executor:
+                            try:
+                                result = tool_executor(
+                                    tool_use['name'],
+                                    tool_use['input'],
+                                    user
+                                )
+                                tool_results.append({
+                                    'type': 'tool_result',
+                                    'tool_use_id': tool_use['id'],
+                                    'content': json.dumps(result, ensure_ascii=False)
+                                })
+                                yield {
+                                    'type': 'tool_result',
+                                    'tool_name': tool_use['name'],
+                                    'result': result
+                                }
+                            except Exception as e:
+                                error_result = {'error': str(e)}
+                                tool_results.append({
+                                    'type': 'tool_result',
+                                    'tool_use_id': tool_use['id'],
+                                    'content': json.dumps(error_result),
+                                    'is_error': True
+                                })
+                                yield {
+                                    'type': 'tool_error',
+                                    'tool_name': tool_use['name'],
+                                    'error': str(e)
+                                }
+                        else:
+                            # Pas d'executor, on ne peut pas exécuter le tool
+                            tool_results.append({
+                                'type': 'tool_result',
+                                'tool_use_id': tool_use['id'],
+                                'content': json.dumps({'error': 'Tool executor not available'}),
+                                'is_error': True
+                            })
+
+                    # Ajouter les messages pour continuer la conversation
+                    current_messages.append({
+                        'role': 'assistant',
+                        'content': response.content
+                    })
+                    current_messages.append({
+                        'role': 'user',
+                        'content': tool_results
+                    })
+
+        except anthropic.APIConnectionError as e:
+            LogUtils.error(f"Erreur de connexion API Claude: {e}")
+            yield {'type': 'error', 'error': 'Impossible de se connecter au service IA'}
+
+        except anthropic.RateLimitError as e:
+            LogUtils.error(f"Rate limit API Claude: {e}")
+            yield {'type': 'error', 'error': 'Service temporairement surchargé, veuillez réessayer'}
+
+        except anthropic.APIStatusError as e:
+            LogUtils.error(f"Erreur API Claude: {e}")
+            yield {'type': 'error', 'error': f'Erreur du service IA: {e.message}'}
+
+        except Exception as e:
+            LogUtils.error("Erreur inattendue lors de l'appel Claude")
+            yield {'type': 'error', 'error': str(e)}
+
+    def chat_completion(
+        self,
+        messages: List,
+        page_context: Dict,
+        user
+    ) -> Dict[str, Any]:
+        """
+        Génère une réponse complète (non-streaming).
+
+        Returns:
+            Dict avec 'content', 'tokens_utilises', ou 'error'
+        """
+        try:
+            # Extraire la question utilisateur
+            user_question = ""
+            if messages:
+                last_msg = messages[-1] if hasattr(messages[-1], 'contenu') else messages[-1]
+                user_question = getattr(last_msg, 'contenu', '') if hasattr(last_msg, 'contenu') else str(last_msg)
+
+            system_prompt = self._build_system_prompt(page_context, user, user_question)
+
+            # Utiliser l'optimisation des messages
+            formatted_messages = self._optimize_messages(messages)
+
+            if not formatted_messages:
+                return {'error': 'Aucun message à traiter'}
+
+            response = self.client.messages.create(
+                model=self._model,
+                max_tokens=self.MAX_TOKENS,
+                system=system_prompt,
+                messages=formatted_messages
+            )
+
+            content = ""
+            for block in response.content:
+                if block.type == "text":
+                    content += block.text
+
+            total_tokens = 0
+            if response.usage:
+                total_tokens = response.usage.input_tokens + response.usage.output_tokens
+
+            return {
+                'content': content,
+                'tokens_utilises': total_tokens,
+                'input_tokens': response.usage.input_tokens if response.usage else 0,
+                'output_tokens': response.usage.output_tokens if response.usage else 0
+            }
+
+        except Exception as e:
+            LogUtils.error("Erreur lors de l'appel Claude")
+            return {'error': str(e)}
+
+    def analyze_code_for_bug(
+        self,
+        error_message: str,
+        code_context: str,
+        user_description: str
+    ) -> Dict[str, Any]:
+        """
+        Analyse du code pour détecter un bug potentiel.
+
+        Returns:
+            Dict avec 'is_bug', 'analysis', 'recommendation'
+        """
+        prompt = f"""Analyse le problème suivant signalé par un utilisateur:
+
+Description de l'utilisateur: {user_description}
+
+Message d'erreur (si disponible): {error_message}
+
+Code source pertinent:
+```
+{code_context}
+```
+
+Réponds au format JSON avec les clés suivantes:
+- is_bug: boolean (true si c'est un bug dans le code, false si c'est une erreur utilisateur)
+- analysis: string (explication du problème)
+- recommendation: string (recommandation pour résoudre le problème)
+- severity: string (low/medium/high si c'est un bug)
+"""
+
+        try:
+            response = self.client.messages.create(
+                model=self._model,
+                max_tokens=1024,
+                messages=[{"role": "user", "content": prompt}]
+            )
+
+            content = response.content[0].text if response.content else "{}"
+
+            # Essayer de parser le JSON
+            try:
+                # Extraire le JSON de la réponse
+                import re
+                json_match = re.search(r'\{[^{}]*\}', content, re.DOTALL)
+                if json_match:
+                    return json.loads(json_match.group())
+            except json.JSONDecodeError:
+                pass
+
+            return {
+                'is_bug': False,
+                'analysis': content,
+                'recommendation': 'Contactez le support si le problème persiste.'
+            }
+
+        except Exception as e:
+            LogUtils.error("Erreur lors de l'analyse de bug")
+            return {
+                'error': str(e),
+                'is_bug': False,
+                'analysis': 'Impossible d\'analyser le problème',
+                'recommendation': 'Veuillez contacter le support technique.'
+            }