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

lucy_assist/migrations/0001_initial.py

@@ -0,0 +1,92 @@
+# Generated migration for lucy_assist
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='ConfigurationLucyAssist',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('created_date', models.DateTimeField(auto_now_add=True)),
+                ('updated_date', models.DateTimeField(auto_now=True, null=True, blank=True)),
+                ('is_active', models.BooleanField(default=True)),
+                ('tokens_disponibles', models.BigIntegerField(default=0)),
+                ('prix_par_million_tokens', models.DecimalField(decimal_places=2, default=10.0, max_digits=10)),
+                ('questions_frequentes', models.JSONField(blank=True, default=list)),
+                ('actif', models.BooleanField(default=True)),
+                ('avatar', models.ImageField(blank=True, null=True, upload_to='')),
+                ('model_app_mapping', models.JSONField(blank=True, default=dict)),
+            ],
+            options={
+                'verbose_name': 'Configuration Lucy Assist',
+                'verbose_name_plural': 'Configuration Lucy Assist',
+            },
+        ),
+        migrations.CreateModel(
+            name='Conversation',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('created_date', models.DateTimeField(auto_now_add=True)),
+                ('updated_date', models.DateTimeField(auto_now=True, null=True, blank=True)),
+                ('is_active', models.BooleanField(default=True)),
+                ('titre', models.CharField(blank=True, max_length=255, null=True)),
+                ('page_contexte', models.CharField(blank=True, max_length=500, null=True)),
+                ('utilisateur', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='lucy_assist_conversations', to=settings.AUTH_USER_MODEL)),
+            ],
+            options={
+                'verbose_name': 'Conversation Lucy Assist',
+                'verbose_name_plural': 'Conversations Lucy Assist',
+                'ordering': ['-created_date'],
+            },
+        ),
+        migrations.CreateModel(
+            name='Message',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('created_date', models.DateTimeField(auto_now_add=True)),
+                ('updated_date', models.DateTimeField(auto_now=True, null=True, blank=True)),
+                ('is_active', models.BooleanField(default=True)),
+                ('repondant', models.CharField(choices=[('UTILISATEUR', 'Utilisateur'), ('CHATBOT', 'Lucy Assist')], max_length=20)),
+                ('contenu', models.TextField()),
+                ('tokens_utilises', models.IntegerField(default=0)),
+                ('type_action', models.CharField(blank=True, choices=[('AIDE_NAVIGATION', 'Aide à la navigation'), ('RECHERCHE', "Recherche d'objets"), ('CRUD', "Création/Modification/Suppresion d'objets"), ('ANALYSE_BUG', 'Analyse de bug'), ('EXPLICATION', 'Explication de fonctionnalité')], max_length=50, null=True)),
+                ('metadata', models.JSONField(blank=True, default=dict)),
+                ('conversation', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='messages', to='lucy_assist.conversation')),
+            ],
+            options={
+                'verbose_name': 'Message Lucy Assist',
+                'verbose_name_plural': 'Messages Lucy Assist',
+                'ordering': ['created_date'],
+            },
+        ),
+        migrations.CreateModel(
+            name='ProjectContextCache',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('created_date', models.DateTimeField(auto_now_add=True)),
+                ('updated_date', models.DateTimeField(auto_now=True, null=True, blank=True)),
+                ('is_active', models.BooleanField(default=True)),
+                ('cache_key', models.CharField(db_index=True, max_length=255, unique=True)),
+                ('contenu', models.JSONField(default=dict)),
+                ('content_hash', models.CharField(blank=True, max_length=64)),
+                ('expire_at', models.DateTimeField()),
+                ('tokens_economises', models.BigIntegerField(default=0)),
+                ('hit_count', models.IntegerField(default=0)),
+            ],
+            options={
+                'verbose_name': 'Cache contexte projet',
+                'verbose_name_plural': 'Caches contexte projet',
+            },
+        ),
+    ]

lucy_assist/models/__init__.py

@@ -0,0 +1,14 @@
+from .base import LucyAssistBaseModel
+from .conversation import Conversation
+from .message import Message
+from .configuration import ConfigurationLucyAssist, get_default_model_app_mapping
+from .project_context_cache import ProjectContextCache
+
+__all__ = [
+    'LucyAssistBaseModel',
+    'Conversation',
+    'Message',
+    'ConfigurationLucyAssist',
+    'get_default_model_app_mapping',
+    'ProjectContextCache',
+]

lucy_assist/models/base.py

@@ -0,0 +1,54 @@
+"""
+Modèle de base pour Lucy Assist.
+Utilise le modèle de base configuré dans les settings ou un modèle par défaut.
+"""
+from django.db import models
+
+from lucy_assist.conf import lucy_assist_settings
+
+
+def get_base_model():
+    """
+    Retourne le modèle de base à utiliser pour les modèles Lucy Assist.
+    Permet de personnaliser le modèle de base via les settings Django.
+    """
+    base_model = lucy_assist_settings.BASE_MODEL
+
+    if base_model is None:
+        # Utiliser un modèle par défaut simple
+        return LucyAssistBaseModel
+
+    if isinstance(base_model, str):
+        # Importer le modèle depuis le chemin string
+        from django.utils.module_loading import import_string
+        return import_string(base_model)
+
+    return base_model
+
+
+class LucyAssistBaseModel(models.Model):
+    """
+    Modèle de base par défaut pour Lucy Assist.
+    Fournit les champs minimaux nécessaires pour le tracking.
+    """
+    created_date = models.DateTimeField(auto_now_add=True)
+    updated_date = models.DateTimeField(auto_now=True, null=True, blank=True)
+    is_active = models.BooleanField(default=True)
+
+    class Meta:
+        abstract = True
+        ordering = ["-created_date"]
+
+
+# Cache pour le modèle de base résolu
+_resolved_base_model = None
+
+
+def get_lucy_assist_model_base():
+    """
+    Retourne le modèle de base résolu (avec cache).
+    """
+    global _resolved_base_model
+    if _resolved_base_model is None:
+        _resolved_base_model = get_base_model()
+    return _resolved_base_model

lucy_assist/models/configuration.py

@@ -0,0 +1,175 @@
+from django.db import models
+from django.core.cache import cache
+
+from lucy_assist.models.base import LucyAssistBaseModel
+from lucy_assist.conf import lucy_assist_settings
+
+
+class ConfigurationLucyAssist(LucyAssistBaseModel):
+    """
+    Configuration singleton pour Lucy Assist.
+    Gère les tokens disponibles et les paramètres globaux.
+    """
+    tokens_disponibles = models.BigIntegerField(default=0)
+    prix_par_million_tokens = models.DecimalField(
+        max_digits=10,
+        decimal_places=2,
+        default=lucy_assist_settings.PRIX_PAR_MILLION_TOKENS
+    )
+    questions_frequentes = models.JSONField(default=list, blank=True)
+    actif = models.BooleanField(default=True)
+    avatar = models.ImageField(null=True, blank=True)
+
+    # Mapping des modèles vers leurs applications Django
+    model_app_mapping = models.JSONField(blank=True, default=dict)
+
+    class Meta:
+        verbose_name = "Configuration Lucy Assist"
+        verbose_name_plural = "Configuration Lucy Assist"
+
+    def __str__(self):
+        return f"Configuration Lucy Assist - {self.tokens_disponibles:,} tokens"
+
+    @classmethod
+    def get_config(cls):
+        """
+        Retourne la configuration singleton.
+        Utilise le cache pour optimiser les performances.
+        """
+        cache_key = 'lucy_assist_config'
+        config = cache.get(cache_key)
+
+        if config is None:
+            config, _ = cls.objects.get_or_create(pk=1)
+            cache.set(cache_key, config, timeout=300)  # Cache 5 minutes
+
+        return config
+
+    def save(self, *args, **kwargs):
+        # Forcer l'ID à 1 pour le singleton
+        self.pk = 1
+        super().save(*args, **kwargs)
+        # Invalider le cache
+        cache.delete('lucy_assist_config')
+
+    @property
+    def tokens_restants_en_euros(self):
+        """Retourne la valeur en euros des tokens restants."""
+        return (self.tokens_disponibles / 1_000_000) * float(self.prix_par_million_tokens)
+
+    @property
+    def conversations_estimees(self):
+        """Estime le nombre de conversations possibles avec les tokens restants."""
+        return int(self.tokens_disponibles / lucy_assist_settings.TOKENS_MOYENS_PAR_CONVERSATION)
+
+    def ajouter_tokens(self, montant_euros):
+        """
+        Ajoute des tokens en fonction d'un montant en euros.
+        Retourne le nombre de tokens ajoutés.
+        """
+        tokens_a_ajouter = int((montant_euros / float(self.prix_par_million_tokens)) * 1_000_000)
+        self.tokens_disponibles += tokens_a_ajouter
+        self.save(update_fields=['tokens_disponibles'])
+        return tokens_a_ajouter
+
+    def a_suffisamment_tokens(self, tokens_requis=2000):
+        """Vérifie si suffisamment de tokens sont disponibles."""
+        return self.tokens_disponibles >= tokens_requis
+
+    def get_questions_frequentes(self):
+        """
+        Retourne les questions fréquentes configurées.
+        Si aucune n'est configurée, retourne les questions par défaut.
+        """
+        if self.questions_frequentes:
+            return self.questions_frequentes
+
+        # Questions par défaut si aucune n'est configurée
+        return lucy_assist_settings.QUESTIONS_FREQUENTES_DEFAULT
+
+    def get_app_for_model(self, model_name: str) -> str:
+        """
+        Retourne le nom de l'application Django pour un modèle donné.
+
+        Args:
+            model_name: Nom du modèle (insensible à la casse)
+
+        Returns:
+            Nom de l'application Django, ou le nom du modèle en minuscules si non trouvé
+        """
+        # Si le mapping est vide, le construire dynamiquement depuis les modèles Django
+        if not self.model_app_mapping:
+            self.model_app_mapping = self._build_model_app_mapping()
+            self.save(update_fields=['model_app_mapping'])
+            # Invalider le cache pour que les prochains appels utilisent la nouvelle valeur
+            cache.delete('lucy_assist_config')
+
+        model_lower = model_name.lower()
+        return self.model_app_mapping.get(model_lower, model_lower)
+
+    def _build_model_app_mapping(self) -> dict:
+        """
+        Construit dynamiquement le mapping modèle -> application
+        en parcourant tous les modèles Django enregistrés.
+
+        Returns:
+            Dict avec les noms de modèles en minuscules comme clés
+            et les noms d'applications comme valeurs.
+        """
+        from django.apps import apps
+
+        mapping = {}
+        apps_prefix = lucy_assist_settings.PROJECT_APPS_PREFIX
+
+        for app_config in apps.get_app_configs():
+            app_label = app_config.label
+
+            # Filtrer les apps si un préfixe est configuré
+            if apps_prefix and not app_config.name.startswith(apps_prefix):
+                continue
+
+            # Utiliser le label de l'app
+            app_name = app_label
+
+            for model in app_config.get_models():
+                model_name_lower = model.__name__.lower()
+                # Ne pas écraser si déjà présent (priorité au premier trouvé)
+                if model_name_lower not in mapping:
+                    mapping[model_name_lower] = app_name
+
+        return mapping
+
+    def update_model_mapping(self, model_name: str, app_name: str) -> None:
+        """
+        Met à jour le mapping pour un modèle spécifique.
+        Utilisé quand le chatbot découvre un nouveau mapping.
+
+        Args:
+            model_name: Nom du modèle
+            app_name: Nom de l'application Django
+        """
+        if not self.model_app_mapping:
+            self.model_app_mapping = {}
+
+        model_lower = model_name.lower()
+        self.model_app_mapping[model_lower] = app_name
+        self.save(update_fields=['model_app_mapping'])
+        cache.delete('lucy_assist_config')
+
+    @classmethod
+    def get_app_for_model_static(cls, model_name: str) -> str:
+        """
+        Version statique pour récupérer l'app d'un modèle.
+        Utilise la config en cache.
+        """
+        config = cls.get_config()
+        return config.get_app_for_model(model_name)
+
+
+def get_default_model_app_mapping() -> dict:
+    """
+    Fonction utilisée par la migration pour la valeur par défaut.
+    Retourne un dict vide car le mapping est maintenant construit
+    dynamiquement lors du premier accès.
+    """
+    return {}

lucy_assist/models/conversation.py

@@ -0,0 +1,54 @@
+from django.conf import settings
+from django.db import models
+
+from lucy_assist.models.base import LucyAssistBaseModel
+
+
+class Conversation(LucyAssistBaseModel):
+    """
+    Modèle représentant une conversation entre un utilisateur et Lucy Assist.
+    """
+    titre = models.CharField(max_length=255, blank=True, null=True)
+    page_contexte = models.CharField(max_length=500, blank=True, null=True)
+
+    # ForeignKey
+    utilisateur = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.CASCADE,
+        related_name='lucy_assist_conversations'
+    )
+
+    class Meta:
+        verbose_name = "Conversation Lucy Assist"
+        verbose_name_plural = "Conversations Lucy Assist"
+        ordering = ['-created_date']
+
+    def __str__(self):
+        user_str = getattr(self.utilisateur, 'email', str(self.utilisateur))
+        return f"Conversation #{self.pk} - {user_str}"
+
+    @property
+    def total_tokens(self):
+        """Retourne le nombre total de tokens utilisés dans cette conversation."""
+        return self.messages.aggregate(
+            total=models.Sum('tokens_utilises')
+        )['total'] or 0
+
+    @property
+    def dernier_message(self):
+        """Retourne le dernier message de la conversation."""
+        return self.messages.order_by('-created_date').first()
+
+    def generer_titre(self):
+        """Génère un titre automatique basé sur le premier message utilisateur."""
+        premier_message = self.messages.filter(
+            repondant='UTILISATEUR'
+        ).order_by('created_date').first()
+
+        if premier_message:
+            # Tronquer le message pour créer un titre
+            contenu = premier_message.contenu[:50]
+            if len(premier_message.contenu) > 50:
+                contenu += "..."
+            self.titre = contenu
+            self.save(update_fields=['titre'])

lucy_assist/models/message.py

@@ -0,0 +1,45 @@
+from django.db import models
+
+from lucy_assist.models.base import LucyAssistBaseModel
+from lucy_assist.constantes import LucyAssistConstantes
+
+
+class Message(LucyAssistBaseModel):
+    """
+    Modèle représentant un message dans une conversation Lucy Assist.
+    """
+    repondant = models.CharField(max_length=20, choices=LucyAssistConstantes.Repondant.tuples)
+    contenu = models.TextField()
+    tokens_utilises = models.IntegerField(default=0)
+    type_action = models.CharField(
+        max_length=50,
+        choices=LucyAssistConstantes.TypeAction.tuples,
+        blank=True,
+        null=True
+    )
+    metadata = models.JSONField(default=dict, blank=True)  # Données supplémentaires (contexte, erreurs, etc.)
+
+    # ForeignKey
+    conversation = models.ForeignKey(
+        'lucy_assist.Conversation',
+        on_delete=models.CASCADE,
+        related_name='messages'
+    )
+
+    class Meta:
+        verbose_name = "Message Lucy Assist"
+        verbose_name_plural = "Messages Lucy Assist"
+        ordering = ['created_date']
+
+    def __str__(self):
+        return f"Message #{self.pk} - {self.get_repondant_display()}"
+
+    @property
+    def est_chatbot(self):
+        """Retourne True si le message vient du chatbot."""
+        return self.repondant == LucyAssistConstantes.Repondant.CHATBOT
+
+    @property
+    def est_utilisateur(self):
+        """Retourne True si le message vient de l'utilisateur."""
+        return self.repondant == LucyAssistConstantes.Repondant.UTILISATEUR

lucy_assist/models/project_context_cache.py

@@ -0,0 +1,213 @@
+"""
+Cache du contexte projet pour optimiser les tokens Claude.
+"""
+import hashlib
+import json
+from datetime import timedelta
+from typing import Optional, Dict, Any
+
+from django.db import models
+from django.core.cache import cache
+from django.utils import timezone
+
+from lucy_assist.models.base import LucyAssistBaseModel
+
+
+class ProjectContextCache(LucyAssistBaseModel):
+    """
+    Cache du contexte projet analysé.
+
+    Stocke les informations sur la structure du projet pour éviter
+    de re-analyser GitLab à chaque requête Claude.
+    """
+    cache_key = models.CharField(
+        max_length=255,
+        unique=True,
+        db_index=True
+    )  # Clé unique pour identifier le type de contexte
+    contenu = models.JSONField(default=dict)  # Contenu mis en cache (JSON)
+    content_hash = models.CharField(max_length=64, blank=True)  # Hash du contenu source pour détecter les changements
+    expire_at = models.DateTimeField()
+    tokens_economises = models.BigIntegerField(default=0)  # Nombre de tokens économisés grâce au cache
+    hit_count = models.IntegerField(default=0)  # Nombre d'utilisations
+
+    class Meta:
+        verbose_name = "Cache contexte projet"
+        verbose_name_plural = "Caches contexte projet"
+
+    def __str__(self):
+        return f"Cache: {self.cache_key}"
+
+    @property
+    def is_expired(self) -> bool:
+        """Vérifie si le cache est expiré."""
+        return timezone.now() > self.expire_at
+
+    @property
+    def is_valid(self) -> bool:
+        """Vérifie si le cache est valide (non expiré)."""
+        return not self.is_expired
+
+    def increment_hit(self, tokens_saved: int = 0):
+        """Incrémente le compteur d'utilisation."""
+        self.hit_count += 1
+        self.tokens_economises += tokens_saved
+        self.save(update_fields=['hit_count', 'tokens_economises'])
+
+    @classmethod
+    def get_or_create_cache(
+            cls,
+            cache_key: str,
+            ttl_hours: int = 24
+    ) -> 'ProjectContextCache':
+        """
+        Récupère ou crée un cache.
+
+        Args:
+            cache_key: Clé unique du cache
+            ttl_hours: Durée de vie en heures
+
+        Returns:
+            Instance de ProjectContextCache
+        """
+        expire_at = timezone.now() + timedelta(hours=ttl_hours)
+
+        cache_obj, created = cls.objects.get_or_create(
+            cache_key=cache_key,
+            defaults={
+                'expire_at': expire_at,
+                'contenu': {}
+            }
+        )
+
+        # Renouveler si expiré
+        if cache_obj.is_expired:
+            cache_obj.expire_at = expire_at
+            cache_obj.contenu = {}
+            cache_obj.content_hash = ''
+            cache_obj.save()
+
+        return cache_obj
+
+    @classmethod
+    def get_cached_content(
+            cls,
+            cache_key: str,
+            content_hash: Optional[str] = None
+    ) -> Optional[Dict]:
+        """
+        Récupère le contenu mis en cache si valide.
+
+        Args:
+            cache_key: Clé du cache
+            content_hash: Hash pour vérifier si le contenu a changé
+
+        Returns:
+            Contenu caché ou None si invalide/expiré
+        """
+        # D'abord vérifier le cache Django (plus rapide)
+        django_cache_key = f"lucy_assist_context_{cache_key}"
+        cached = cache.get(django_cache_key)
+        if cached:
+            return cached
+
+        try:
+            cache_obj = cls.objects.get(cache_key=cache_key)
+
+            # Vérifier l'expiration
+            if cache_obj.is_expired:
+                return None
+
+            # Vérifier le hash si fourni
+            if content_hash and cache_obj.content_hash != content_hash:
+                return None
+
+            # Mettre en cache Django pour accès rapide
+            cache.set(django_cache_key, cache_obj.contenu, timeout=3600)
+
+            return cache_obj.contenu
+
+        except cls.DoesNotExist:
+            return None
+
+    @classmethod
+    def set_cached_content(
+            cls,
+            cache_key: str,
+            contenu: Dict,
+            content_hash: str = '',
+            ttl_hours: int = 24
+    ) -> 'ProjectContextCache':
+        """
+        Stocke le contenu en cache.
+
+        Args:
+            cache_key: Clé du cache
+            contenu: Contenu à cacher
+            content_hash: Hash du contenu source
+            ttl_hours: Durée de vie en heures
+
+        Returns:
+            Instance de ProjectContextCache
+        """
+        expire_at = timezone.now() + timedelta(hours=ttl_hours)
+
+        cache_obj, _ = cls.objects.update_or_create(
+            cache_key=cache_key,
+            defaults={
+                'contenu': contenu,
+                'content_hash': content_hash,
+                'expire_at': expire_at
+            }
+        )
+
+        # Mettre aussi en cache Django
+        django_cache_key = f"lucy_assist_context_{cache_key}"
+        cache.set(django_cache_key, contenu, timeout=ttl_hours * 3600)
+
+        return cache_obj
+
+    @staticmethod
+    def compute_hash(content: Any) -> str:
+        """Calcule le hash d'un contenu."""
+        if isinstance(content, dict) or isinstance(content, list):
+            content = json.dumps(content, sort_keys=True)
+        return hashlib.sha256(str(content).encode()).hexdigest()[:16]
+
+    @classmethod
+    def invalidate_cache(cls, cache_key: str):
+        """Invalide un cache spécifique."""
+        # Supprimer du cache Django
+        django_cache_key = f"lucy_assist_context_{cache_key}"
+        cache.delete(django_cache_key)
+
+        # Supprimer de la BDD
+        cls.objects.filter(cache_key=cache_key).delete()
+
+    @classmethod
+    def invalidate_all(cls):
+        """Invalide tous les caches Lucy Assist."""
+        # Supprimer tous les caches (la suppression du cache Django pattern n'est pas disponible)
+        cls.objects.all().delete()
+
+    @classmethod
+    def get_stats(cls) -> Dict:
+        """Retourne les statistiques des caches."""
+        from django.db.models import Sum, Count
+
+        stats = cls.objects.aggregate(
+            total_caches=Count('id'),
+            total_hits=Sum('hit_count'),
+            total_tokens_saved=Sum('tokens_economises')
+        )
+
+        active_caches = cls.objects.filter(
+            expire_at__gt=timezone.now()
+        ).count()
+
+        return {
+            'total_caches': stats['total_caches'] or 0,
+            'active_caches': active_caches,
+            'total_hits': stats['total_hits'] or 0,
+            'total_tokens_saved': stats['total_tokens_saved'] or 0
+        }

lucy_assist/services/__init__.py

@@ -0,0 +1,21 @@
+from .claude_service import ClaudeService
+from .gitlab_service import GitLabService
+from .context_service import ContextService
+from .crud_service import CRUDService
+from .project_context_service import ProjectContextService
+from .tool_executor_service import ToolExecutorService, create_tool_executor
+from .tools_definition import LUCY_ASSIST_TOOLS, get_app_for_model
+from .bug_notification_service import BugNotificationService
+
+__all__ = [
+    'ClaudeService',
+    'GitLabService',
+    'ContextService',
+    'CRUDService',
+    'ProjectContextService',
+    'ToolExecutorService',
+    'create_tool_executor',
+    'LUCY_ASSIST_TOOLS',
+    'get_app_for_model',
+    'BugNotificationService',
+]