clemscript_analyzer.py

import re
from typing import Dict, List, Any

class ClemScriptAnalyzer:
    """Analyseur de prompts français pour détecter les concepts ClemScript"""
    
    def __init__(self):
        # Dictionnaire étendu avec 550+ mots-clés français vers les concepts ClemScript
        self.concept_keywords = {
            'variable': [
                # Mots de base
                'variable', 'var', 'créer une variable', 'déclarer', 'définir', 'stocker', 'créer', 'initialiser', 
                'nouvelle variable', 'faire une variable', 'mets', 'définis', 'établir', 'constituer',
                # Synonymes variés
                'conteneur', 'réceptacle', 'espace', 'place', 'zone', 'emplacement', 'stockage', 'mémoire',
                'donner un nom', 'baptiser', 'nommer', 'appeler', 'désigner', 'identifier', 'étiqueter',
                'assigner', 'attribuer', 'affecter', 'octroyer', 'accorder', 'donner', 'fournir',
                # Actions
                'garde', 'conserve', 'retient', 'sauvegarde', 'enregistre', 'mémorise', 'retenir',
                'mettre dans', 'placer dans', 'ranger dans', 'insérer dans', 'loger dans',
                # Expressions naturelles
                'je veux une', 'il me faut une', 'créons une', 'faisons une', 'construisons une',
                'élaborer une', 'concevoir une', 'former une', 'produire une', 'générer une'
            ],
            
            'console': [
                # Mots de base
                'affiche', 'afficher', 'console', 'écrire', 'imprimer', 'print', 'message', 'montre', 'montrer',
                'dire', 'sortir', 'output', 'écrit', 'imprime', 'affichage', 'texte', 'voir', 'visualiser',
                # Synonymes d'affichage
                'présente', 'présenter', 'exhiber', 'exposer', 'révéler', 'dévoiler', 'manifester',
                'rendre visible', 'faire apparaître', 'faire voir', 'donner à voir', 'mettre en évidence',
                'illustrer', 'démontrer', 'indiquer', 'signaler', 'notifier', 'communiquer',
                # Actions de communication
                'transmettre', 'véhiculer', 'diffuser', 'propager', 'divulguer', 'publier', 'proclamer',
                'annoncer', 'déclarer', 'exprimer', 'formuler', 'articuler', 'prononcer', 'énoncer',
                # Expressions naturelles
                'fais apparaître', 'sors le message', 'mets à l\'écran', 'projette', 'lance le texte',
                'balance', 'crache', 'sort', 'produis', 'génère à l\'écran', 'tape', 'inscris'
            ],
            
            'condition': [
                # Mots de base
                'condition', 'si', 'if', 'alors', 'when', 'quand', 'test', 'vérifie', 'vérifier',
                'contrôle', 'selon', 'sinon', 'else', 'autrement',
                # Tests et vérifications
                'examine', 'inspecte', 'analyse', 'évalue', 'juge', 'détermine', 'établit', 'constate',
                'observe', 'regarde', 'surveille', 'contrôle', 'supervise', 'audit', 'scrute',
                # Conditions logiques
                'cas où', 'dans le cas', 'supposons que', 'admettons que', 'si jamais', 'au cas où',
                'en supposant', 'pourvu que', 'à condition que', 'dans l\'hypothèse', 'si par hasard',
                # Alternatives
                'sinon', 'autrement dit', 'dans le cas contraire', 'à défaut', 'faute de quoi',
                'sans quoi', 'sans cela', 'sans ça', 'ou bien', 'ou alors', 'ou sinon',
                # Comparaisons
                'compare', 'confronte', 'oppose', 'met en balance', 'pèse', 'mesure contre'
            ],
            
            'boucle': [
                # Mots de base
                'boucle', 'répéter', 'for', 'while', 'itérer', 'parcourir', 'faire', 'plusieurs fois',
                'tant que', 'jusqu', 'recommencer', 'reprendre', 'répétition', 'loop',
                # Synonymes de répétition
                'réitérer', 'redire', 'refaire', 'reproduire', 'dupliquer', 'multiplier', 'récidiver',
                'recommencer', 'remettre', 'reprendre', 'continuer', 'poursuivre', 'persévérer',
                # Cycles et itérations
                'cycle', 'tour', 'passage', 'rotation', 'révolution', 'circuit', 'ronde', 'série',
                'suite', 'enchaînement', 'succession', 'séquence', 'processus répétitif',
                # Expressions temporelles
                'pendant que', 'durant', 'au cours de', 'le temps que', 'aussi longtemps que',
                'jusqu\'à ce que', 'en attendant que', 'tant et si bien que',
                # Actions répétitives
                'réexécute', 'recompte', 'retraverse', 'rebalaye', 'reparcourt', 'revisite'
            ],
            
            'input': [
                # Mots de base
                'saisie', 'input', 'demander', 'entrée utilisateur', 'demande', 'question', 'questionner',
                'réponse', 'utilisateur', 'clavier', 'tape', 'entrer', 'saisi', 'obtenir', 'récupérer',
                # Synonymes de demande
                'requête', 'sollicitation', 'supplication', 'prière', 'appel', 'invitation', 'incitation',
                'interrogation', 'enquête', 'sondage', 'consultation', 'questionnement',
                # Actions d'obtention
                'recueillir', 'collecter', 'rassembler', 'réunir', 'amasser', 'accumuler', 'capturer',
                'saisir', 'prendre', 'attraper', 'acquérir', 'glaner', 'ramasser', 'puiser',
                # Interactions utilisateur
                'dialogue', 'conversation', 'échange', 'communication', 'interaction', 'contact',
                'interface', 'liaison', 'relation', 'correspondance', 'discussion',
                # Expressions naturelles
                'pose la question', 'va chercher', 'va demander', 'interroge l\'utilisateur',
                'fais saisir', 'fais taper', 'laisse l\'utilisateur écrire', 'attend une réponse'
            ],
            
            'math': [
                # Mots de base
                'calcul', 'mathématique', 'math', 'carré', 'racine', 'square', 'sqrt', 'abs', 'addition',
                'soustraction', 'multiplication', 'division', 'puissance', 'plus', 'moins', 'fois', 'diviser',
                'valeur absolue',
                # Opérations étendues
                'somme', 'différence', 'produit', 'quotient', 'reste', 'modulo', 'exposant', 'logarithme',
                'sinus', 'cosinus', 'tangente', 'arcsinus', 'arccosinus', 'arctangente',
                # Synonymes des opérations
                'additionner', 'soustraire', 'multiplier', 'diviser', 'élever à la puissance',
                'mettre au carré', 'prendre la racine', 'extraire la racine', 'calculer la racine',
                # Expressions mathématiques
                'équation', 'formule', 'expression', 'terme', 'facteur', 'coefficient', 'constante',
                'variable mathématique', 'inconnue', 'paramètre', 'argument', 'résultat',
                # Fonctions spéciales
                'arrondir', 'tronquer', 'plancher', 'plafond', 'maximum', 'minimum', 'moyenne'
            ],
            
            'color': [
                # Mots de base
                'couleur', 'color', 'rouge', 'vert', 'bleu', 'jaune', 'coloré', 'colore', 'colorer',
                'teinte', 'nuance', 'rose', 'violet', 'orange', 'noir', 'blanc',
                # Couleurs étendues
                'écarlate', 'cramoisi', 'vermillon', 'bordeaux', 'pourpre', 'magenta', 'fuchsia',
                'emeraude', 'olive', 'lime', 'menthe', 'turquoise', 'cyan', 'azur', 'bleu marine',
                'indigo', 'lavande', 'mauve', 'améthyste', 'lilas', 'prune', 'aubergine',
                'doré', 'argenté', 'bronze', 'cuivre', 'ocre', 'beige', 'crème', 'ivoire',
                # Expressions de couleur
                'coloration', 'pigmentation', 'teinture', 'peinture', 'coloris', 'chromatisme',
                'tonalité', 'saturation', 'luminosité', 'brillance', 'éclat', 'intensité',
                # Actions
                'peindre', 'teindre', 'pigmenter', 'enluminer', 'coloriser', 'nuancer'
            ],
            
            'quiz': [
                # Mots de base
                'quiz', 'question', 'questionnaire', 'qcm', 'test', 'examen', 'interrogation',
                'sondage', 'enquête', 'choix multiple',
                # Types d'évaluations
                'épreuve', 'contrôle', 'vérification', 'assessment', 'évaluation', 'diagnostic',
                'audit', 'inspection', 'révision', 'bilan', 'check-up', 'vérif',
                # Formats de questions
                'questionnaire à choix multiple', 'qru', 'question à réponse unique',
                'vrai ou faux', 'question ouverte', 'question fermée', 'devinette', 'énigme',
                # Contexte éducatif
                'apprentissage', 'formation', 'enseignement', 'pédagogie', 'didactique',
                'instruction', 'éducation', 'cours', 'leçon', 'tutoriel'
            ],
            
            'interaction': [
                # Mots de base
                'interaction', 'interactif', 'choix', 'menu', 'sélection', 'option', 'décision',
                'aventure', 'histoire', 'jeu', 'scénario', 'navigate',
                # Types d'interactions
                'navigation', 'parcours', 'chemin', 'trajet', 'itinéraire', 'route', 'passage',
                'exploration', 'découverte', 'recherche', 'quête', 'mission', 'objectif',
                # Éléments narratifs
                'récit', 'conte', 'fable', 'légende', 'mythe', 'saga', 'épopée', 'chronique',
                'narration', 'storytelling', 'intrigue', 'plot', 'trame', 'fil conducteur',
                # Choix et décisions
                'alternative', 'possibilité', 'éventualité', 'variante', 'solution', 'issue',
                'sortie', 'aboutissement', 'conclusion', 'fin', 'dénouement'
            ],
            
            'random': [
                # Mots de base
                'aléatoire', 'random', 'hasard', 'générer', 'nombre aléatoire', 'tirage', 'chance',
                'probabilité', 'loto', 'dés', 'pile ou face',
                # Synonymes du hasard
                'fortune', 'sort', 'destin', 'fatalité', 'providence', 'coïncidence', 'accident',
                'imprévu', 'inattendu', 'fortuit', 'casuel', 'contingent', 'arbitraire',
                # Jeux de hasard
                'roulette', 'casino', 'pari', 'mise', 'enjeu', 'jackpot', 'gagnant', 'perdant',
                'tirage au sort', 'loterie', 'tombola', 'bingo', 'grattage',
                # Expressions de génération
                'créer au hasard', 'produire aléatoirement', 'tirer au sort', 'sélectionner au hasard',
                'choisir arbitrairement', 'piocher', 'mélanger', 'brasser', 'randomiser'
            ],
            
            'comment': [
                # Mots de base
                'commentaire', 'comment', 'note', 'explication', 'documentation', 'remarque',
                # Types de documentation
                'annotation', 'observation', 'précision', 'clarification', 'éclaircissement',
                'aide-mémoire', 'mémo', 'post-it', 'rappel', 'indication', 'instruction',
                # Actions documentaires
                'expliquer', 'détailler', 'préciser', 'clarifier', 'élucider', 'expliciter',
                'commenter', 'annoter', 'gloser', 'interpréter', 'analyser', 'décortiquer'
            ],
            
            'function': [
                # Mots de base
                'fonction', 'méthode', 'procédure', 'routine', 'sous-programme',
                # Synonymes techniques
                'module', 'composant', 'bloc', 'segment', 'section', 'partie', 'fragment',
                'algorithme', 'séquence', 'processus', 'traitement', 'opération',
                # Actions de création
                'créer une fonction', 'définir une méthode', 'construire une routine',
                'élaborer un algorithme', 'concevoir un processus'
            ],
            
            # Nouveaux concepts avancés pour une IA plus intelligente
            'animation': [
                'animer', 'animation', 'mouvement', 'déplacer', 'bouger', 'faire bouger',
                'transition', 'effet', 'transformation', 'métamorphose', 'changement progressif',
                'fondu', 'apparition', 'disparition', 'rotation', 'zoom', 'slide', 'glissement'
            ],
            
            'audio': [
                'son', 'audio', 'musique', 'bruit', 'mélodie', 'jouer un son', 'émettre',
                'sonorité', 'acoustique', 'harmonie', 'rythme', 'tempo', 'volume',
                'silence', 'pause sonore', 'écho', 'réverbération', 'signal sonore'
            ],
            
            'data': [
                'données', 'data', 'information', 'base de données', 'fichier', 'sauvegarde',
                'stockage', 'enregistrement', 'backup', 'export', 'import', 'csv', 'json',
                'tableau', 'liste', 'collection', 'ensemble', 'série', 'database', 'bdd'
            ],
            
            'ai': [
                'intelligence artificielle', 'ia', 'ai', 'machine learning', 'apprentissage',
                'prédiction', 'analyse prédictive', 'reconnaissance', 'classification',
                'algorithme intelligent', 'réseau de neurones', 'deep learning', 'neural'
            ],
            
            'network': [
                'réseau', 'internet', 'connexion', 'api', 'web', 'http', 'url', 'lien',
                'télécharger', 'upload', 'download', 'synchronisation', 'cloud', 'serveur',
                'protocole', 'communication', 'échange de données'
            ],
            
            'game': [
                'jeu', 'game', 'joueur', 'score', 'niveau', 'points', 'victoire', 'défaite',
                'règles', 'plateau', 'cartes', 'dés', 'puzzle', 'énigme', 'challenge',
                'compétition', 'tournoi', 'classement', 'highscore', 'gaming'
            ]
        }
        
        # Patterns pour extraire des valeurs spécifiques
        self.value_patterns = {
            'variable_name': r'(?:variable|var|créer|stocker|initialiser|mets)\s+(\w+)',
            'variable_value': r'(?:valeur|value|=|avec|égal|est)\s*(["\']?[^,"\'\n]+["\']?)',
            'number': r'\b(\d+(?:\.\d+)?)\b',
            'string': r'["\']([^"\']+)["\']',
            'comparison': r'(plus grand|plus petit|égal|supérieur|inférieur|>|<|=|>=|<=|différent|!=)',
            'keywords': r'\b(forêt|montagne|océan|mer|ville|maison|château|plage|désert|[\w]{3,})\b',
            'colors': r'\b(rouge|vert|bleu|jaune|rose|violet|noir|blanc|orange|gris|red|green|blue|yellow|magenta|cyan|white|black)\b',
            'loop_range': r'(?:de|from)\s+(\d+)\s+(?:à|to|jusqu)\s+(\d+)',
            'math_operation': r'(carré|racine|valeur absolue|square|sqrt|abs|addition|soustraction|multiplication|division)',
            'message_content': r'(?:affiche|montre|dit|écrit)\s+["\']?([^"\']+)["\']?',
            'input_prompt': r'(?:demande|questionne|input)\s+["\']?([^"\']+)["\']?'
        }
    
    def analyze(self, prompt: str) -> Dict[str, Any]:
        """Analyse intelligente et contextuelle d'un prompt français"""
        prompt_lower = prompt.lower()
        
        analysis = {
            'concepts': [],
            'values': {},
            'confidence_scores': {},
            'context': {},
            'intent': None,
            'raw_prompt': prompt
        }
        
        # Analyse contextuelle des concepts avec scoring
        concept_scores = {}
        for concept, keywords in self.concept_keywords.items():
            score = 0
            matched_keywords = []
            for keyword in keywords:
                if keyword in prompt_lower:
                    # Score pondéré selon la longueur et la spécificité du mot-clé
                    keyword_score = len(keyword.split()) * 2 + (len(keyword) / 10)
                    score += keyword_score
                    matched_keywords.append(keyword)
            
            if score > 0:
                concept_scores[concept] = score
                analysis['concepts'].append(concept)
                analysis['confidence_scores'][concept] = min(score / 10, 1.0)  # Normalisation
        
        # Détection d'intention globale
        analysis['intent'] = self._detect_intent(prompt_lower)
        
        # Analyse contextuelle
        analysis['context'] = self._analyze_context(prompt_lower)
        
        # Extraire les valeurs avec amélioration contextuelle
        self._extract_values_enhanced(prompt, analysis)
        
        # Tri des concepts par score de confiance
        analysis['concepts'] = sorted(analysis['concepts'], 
                                     key=lambda x: analysis['confidence_scores'].get(x, 0), 
                                     reverse=True)
        
        return analysis
    
    def _extract_values(self, prompt: str, analysis: Dict[str, Any]) -> None:
        """Extrait des valeurs spécifiques du prompt"""
        
        # Nom de variable - amélioration pour capturer plus de patterns
        var_name_patterns = [
            r'(?:variable|var|créer|stocker|initialiser|mets|définis?)\s+(\w+)',
            r'(\w+)\s+(?:avec|=|égal)\s+(?:la\s+)?valeur',
            r'appeler?\s+(\w+)\s+(?:la\s+)?variable'
        ]
        
        for pattern in var_name_patterns:
            var_name_match = re.search(pattern, prompt.lower())
            if var_name_match:
                analysis['values']['variable_name'] = var_name_match.group(1)
                break
        
        # Valeur de variable
        var_value_match = re.search(self.value_patterns['variable_value'], prompt)
        if var_value_match:
            value = var_value_match.group(1).strip('"\'')
            analysis['values']['variable_value'] = value
        
        # Nombres
        numbers = re.findall(self.value_patterns['number'], prompt)
        if numbers:
            analysis['values']['numbers'] = numbers
        
        # Chaînes de caractères entre guillemets
        strings = re.findall(self.value_patterns['string'], prompt)
        if strings:
            analysis['values']['strings'] = strings
        
        # Comparaisons
        comparison_match = re.search(self.value_patterns['comparison'], prompt.lower())
        if comparison_match:
            comparison = comparison_match.group(1)
            # Convertir en opérateur
            comparison_map = {
                'plus grand': '>',
                'supérieur': '>',
                'plus petit': '<',
                'inférieur': '<',
                'égal': '=='
            }
            analysis['values']['comparison'] = comparison_map.get(comparison, comparison)
        
        # Couleurs
        colors = re.findall(self.value_patterns['colors'], prompt.lower())
        if colors:
            # Mapper les couleurs françaises vers l'anglais
            color_map = {
                'rouge': 'red',
                'vert': 'green',
                'bleu': 'blue',
                'jaune': 'yellow',
                'rose': 'magenta',
                'violet': 'magenta',
                'noir': 'black',
                'blanc': 'white'
            }
            mapped_colors = [color_map.get(color, color) for color in colors]
            analysis['values']['colors'] = mapped_colors
        
        # Mots-clés pour interactions (forêt, montagne, etc.)
        keywords = re.findall(r'\b(forêt|montagne|océan|mer|ville|maison|[\w]{3,})\b', prompt.lower())
        if keywords:
            # Filtrer les mots courants
            common_words = {'avec', 'dans', 'pour', 'sur', 'une', 'des', 'les', 'que', 'qui', 'est', 'sont', 'comme', 'alors', 'quand'}
            filtered_keywords = [k for k in keywords if k not in common_words and len(k) > 2]
            if filtered_keywords:
                analysis['values']['keywords'] = filtered_keywords
        
        # Extraire les réponses pour les interactions
        if any(word in prompt.lower() for word in ['répondre', 'réponse', 'dire', 'affiche']):
            # Chercher les patterns "répondre X quand Y" ou "dire X si Y"
            response_patterns = [
                r'répondre\s+([^q]+)\s+quand\s+(\w+)',
                r'dire\s+([^s]+)\s+si\s+(\w+)',
                r'affiche\s+([^q]+)\s+quand\s+(\w+)'
            ]
            for pattern in response_patterns:
                matches = re.findall(pattern, prompt.lower())
                if matches:
                    analysis['values']['responses'] = matches
                    break
                    
        # Extraire les plages de nombres pour les boucles
        loop_match = re.search(self.value_patterns['loop_range'], prompt)
        if loop_match:
            analysis['values']['loop_start'] = loop_match.group(1)
            analysis['values']['loop_end'] = loop_match.group(2)
            
        # Détecter les opérations mathématiques spécifiques
        math_op_match = re.search(self.value_patterns['math_operation'], prompt.lower())
        if math_op_match:
            analysis['values']['math_operation'] = math_op_match.group(1)
            
    
    def _detect_intent(self, prompt_lower: str) -> str:
        """Détecte l'intention principale du prompt"""
        creation_words = ['créer', 'faire', 'construire', 'générer', 'produire']
        display_words = ['afficher', 'montrer', 'voir', 'présenter']
        calculation_words = ['calculer', 'compter', 'évaluer', 'résoudre']
        interaction_words = ['demander', 'questionner', 'interagir', 'choisir']
        
        if any(word in prompt_lower for word in creation_words):
            return 'création'
        elif any(word in prompt_lower for word in display_words):
            return 'affichage'
        elif any(word in prompt_lower for word in calculation_words):
            return 'calcul'
        elif any(word in prompt_lower for word in interaction_words):
            return 'interaction'
        else:
            return 'général'
    
    def _analyze_context(self, prompt_lower: str) -> dict:
        """Analyse le contexte du prompt"""
        context = {
            'complexity': 'simple',
            'domain': 'général',
            'urgency': 'normale'
        }
        
        # Détection de la complexité
        complex_indicators = ['plusieurs', 'complexe', 'avancé', 'détaillé', 'sophistiqué']
        if any(indicator in prompt_lower for indicator in complex_indicators):
            context['complexity'] = 'complexe'
        
        # Détection du domaine
        math_domain = ['mathématique', 'calcul', 'équation', 'formule']
        game_domain = ['jeu', 'aventure', 'histoire', 'quiz']
        ui_domain = ['interface', 'menu', 'bouton', 'affichage']
        
        if any(word in prompt_lower for word in math_domain):
            context['domain'] = 'mathématiques'
        elif any(word in prompt_lower for word in game_domain):
            context['domain'] = 'jeu'
        elif any(word in prompt_lower for word in ui_domain):
            context['domain'] = 'interface'
        
        return context
    
    def _extract_values_enhanced(self, prompt: str, analysis: dict) -> None:
        """Version améliorée de l'extraction de valeurs avec IA contextuelle"""
        # Appeler d'abord la méthode originale
        self._extract_values(prompt, analysis)
        
        # Améliorations contextuelles
        prompt_lower = prompt.lower()
        
        # Extraction intelligente de noms de variables basée sur le contexte
        if not analysis['values'].get('variable_name'):
            context_patterns = [
                r'appel(?:er|ons|ez)?\s+(?:ça|cela|la|le)\s+(\w+)',
                r'(?:nom|appellation|dénomination)\s+(\w+)',
                r'(\w+)\s+(?:comme|en tant que|pour)\s+(?:nom|variable)'
            ]
            
            for pattern in context_patterns:
                match = re.search(pattern, prompt_lower)
                if match:
                    analysis['values']['variable_name'] = match.group(1)
                    break
        
        # Extraction de valeurs contextuelles plus intelligente
        if not analysis['values'].get('variable_value'):
            value_patterns = [
                r'(?:contenir|avoir|égaler|valoir)\s+([^,\.\n]+)',
                r'(?:c\'est|c\'est-à-dire|soit)\s+([^,\.\n]+)'
            ]
            
            for pattern in value_patterns:
                match = re.search(pattern, prompt_lower)
                if match:
                    value = match.group(1).strip()
                    if value and len(value) < 50:  # Éviter les valeurs trop longues
                        analysis['values']['variable_value'] = value
                        break
        
        # Extraction de contexte pour les interactions
        if 'interaction' in analysis.get('concepts', []):
            scenario_patterns = [
                r'(?:scénario|histoire|contexte)\s+([^,\.\n]+)',
                r'(?:dans|avec|sur)\s+(?:un|une|le|la)\s+([^,\.\n]+)'
            ]
            
            for pattern in scenario_patterns:
                match = re.search(pattern, prompt_lower)
                if match:
                    scenario = match.group(1).strip()
                    if scenario:
                        analysis['values']['scenario'] = scenario
                        break
        
        # Intelligence avancée pour détection des interactions et choix
        self._extract_smart_interactions(prompt, analysis)
    
    def _extract_smart_interactions(self, prompt: str, analysis: dict) -> None:
        """Extraction intelligente des interactions, choix et réponses"""
        prompt_lower = prompt.lower()
        
        # Détection des choix multiples avec formats variés
        choice_patterns = [
            r'(?:choix|options?|alternatives?)[\s:]*([^.\n]+)',
            r'(?:entre|parmi)[\s]+([^.\n]+?)(?:\s+(?:choisir|sélectionner))?',
            r'(\w+)[\s]*ou[\s]*(\w+)',  # Format "A ou B"
            r'(?:soit|choisis?)[\s]+([^,.\n]+?)(?:[\s]*,[\s]*([^,.\n]+?))*'
        ]
        
        choices_found = []
        for pattern in choice_patterns:
            matches = re.findall(pattern, prompt_lower)
            for match in matches:
                if isinstance(match, tuple):
                    choices_found.extend([choice.strip() for choice in match if choice.strip()])
                else:
                    # Séparer les choix par des délimiteurs communs
                    parts = re.split(r'[,;|/]|\s+ou\s+|\s+et\s+', match)
                    choices_found.extend([part.strip() for part in parts if part.strip()])
        
        if choices_found:
            # Nettoyer et limiter les choix
            clean_choices = []
            for choice in choices_found:
                choice = choice.strip('"\'').strip()
                if len(choice) > 2 and len(choice) < 30:  # Filtrer les choix valides
                    clean_choices.append(choice)
            
            if clean_choices:
                analysis['values']['detected_choices'] = clean_choices[:6]  # Max 6 choix
        
        # Détection des mappings condition-réponse intelligents
        response_patterns = [
            r'(?:si|quand|lorsque)[\s]+([^,.\n]+?)[\s]+(?:alors|faire|dire|afficher|répondre)[\s]+([^,.\n]+)',
            r'(?:pour|avec)[\s]+([^,.\n]+?)[\s]+(?:dire|afficher|répondre)[\s]+([^,.\n]+)',
            r'([^,.\n]+?)[\s]*→[\s]*([^,.\n]+)',  # Format avec flèche
            r'([^,.\n]+?)[\s]*:[\s]*([^,.\n]+)'   # Format avec deux-points
        ]
        
        response_mappings = []
        for pattern in response_patterns:
            matches = re.findall(pattern, prompt_lower)
            for condition, response in matches:
                condition = condition.strip().strip('"\'')
                response = response.strip().strip('"\'')
                if len(condition) > 2 and len(response) > 2:
                    response_mappings.append({
                        'condition': condition,
                        'response': response
                    })
        
        if response_mappings:
            analysis['values']['response_mappings'] = response_mappings[:5]
        
        # Détection de contexte de jeu/aventure
        adventure_keywords = ['aventure', 'histoire', 'jeu', 'quête', 'mission', 'exploration', 'parcours']
        if any(keyword in prompt_lower for keyword in adventure_keywords):
            analysis['values']['adventure_mode'] = True
            
            # Détecter les lieux/environnements
            location_patterns = r'\b(forêt|montagne|océan|mer|ville|maison|château|plage|désert|cave|grotte|tunnel|pont|rivière|lac|école|hôpital|restaurant|café|magasin|parc|jardin)\b'
            locations = re.findall(location_patterns, prompt_lower)
            if locations:
                analysis['values']['adventure_locations'] = list(set(locations))  # Éliminer les doublons