fix: chat logic

modules/info_extractor.py

@@ -1,4 +1,3 @@
-# modules/info_extractor.py - 增强版本（添加预算识别）
 import re
 from utils.logger import log
 
@@ -7,33 +6,42 @@ class InfoExtractor:
         self.config = config
     
     def extract(self, message: str) -> dict:
-        """从用户消息中提取信息"""
+        """从用户消息中提取信息 - 调试版"""
         extracted_info = {}
+        message_clean = message.strip()
+        
+        log.info(f"🔍 开始提取信息，消息: '{message_clean}'")
         
         # 1. 提取目的地信息
-        destination = self._extract_destination(message)
+        destination = self._extract_destination(message_clean)
         if destination:
             extracted_info['destination'] = destination
+            log.info(f"✅ 提取到目的地: {destination['name']}")
         
         # 2. 提取天数信息
-        duration = self._extract_duration(message)
+        duration = self._extract_duration(message_clean)
         if duration:
             extracted_info['duration'] = duration
+            log.info(f"✅ 提取到天数: {duration['days']}天")
         
-        # 3. 提取预算信息（新增）
-        budget = self._extract_budget(message)
+        # 3. 提取预算信息
+        budget = self._extract_budget(message_clean)
         if budget:
             extracted_info['budget'] = budget
+            log.info(f"✅ 提取到预算: {budget.get('description', '未知')}")
         
+        log.info(f"📋 最终提取结果: {list(extracted_info.keys())}")
         return extracted_info
     
     def _extract_destination(self, message: str) -> dict:
-        """提取目的地信息"""
+        """提取目的地信息 - 增强日志"""
         message_lower = message.lower()
+        log.info(f"🏙️ 检查目的地，消息: '{message_lower}'")
         
         # 从配置中的城市列表匹配
         for city_key, city_info in self.config.cities.items():
             if city_key in message_lower:
+                log.info(f"✅ 匹配到城市key: '{city_key}' -> {city_info['name']}")
                 return {
                     'name': city_info['name'],
                     'country': city_info.get('country', ''),
@@ -42,46 +50,50 @@ class InfoExtractor:
                     'avg_daily_budget': city_info.get('avg_daily_budget', 100)
                 }
         
+        log.info("❌ 未匹配到任何目的地")
         return None
     
     def _extract_duration(self, message: str) -> dict:
-        """提取旅行天数"""
-        # 匹配各种天数表达方式
+        """修复天数提取逻辑"""
+        message_clean = message.strip()
+        log.info(f"⏰ 检查天数，消息: '{message_clean}'")
+        
+        # 修复正则表达式顺序和逻辑
         patterns = [
-            r'^(\d+)$',
-            r'(\d+)\s*天',
-            r'(\d+)\s*日',
-            r'(\d+)\s*days?',
-            r'玩\s*(\d+)\s*天',
-            r'待\s*(\d+)\s*天',
-            r'(\d+)\s*个天',
+            r'(\d+)\s*天',          # "3天", "5 天"
+            r'(\d+)\s*日',          # "3日", "5 日" 
+            r'(\d+)\s*days?',       # "3day", "5days"
+            r'玩\s*(\d+)\s*天',      # "玩3天"
+            r'待\s*(\d+)\s*天',      # "待3天"
+            r'^(\d+)$',             # 纯数字 "3" (放在最后)
         ]
         
-        for pattern in patterns:
-            match = re.search(pattern, message.strip(), re.IGNORECASE)
+        for i, pattern in enumerate(patterns):
+            match = re.search(pattern, message_clean, re.IGNORECASE)
             if match:
                 days = int(match.group(1))
                 if 1 <= days <= 30:  # 合理的天数范围
+                    log.info(f"✅ 匹配模式{i+1}: '{pattern}' -> {days}天")
                     return {
                         'days': days,
                         'description': f"{days}天"
                     }
+                else:
+                    log.info(f"❌ 天数超出范围: {days}")
         
+        log.info("❌ 未匹配到任何天数")
         return None
     
     def _extract_budget(self, message: str) -> dict:
-        """提取预算信息（新增功能）"""
+        """提取预算信息 - 增强日志"""
         message_lower = message.lower()
+        log.info(f"💰 检查预算，消息: '{message_lower}'")
         
-        # 1. 匹配具体金额（支持多种货币）
+        # 1. 匹配具体金额
         money_patterns = [
-            # 欧元
             (r'(\d+(?:,\d{3})*(?:\.\d{2})?)\s*(?:欧元|euros?|eur|€)', 'EUR'),
-            # 美元
             (r'(\d+(?:,\d{3})*(?:\.\d{2})?)\s*(?:美元|dollars?|usd|\$)', 'USD'),
-            # 人民币
             (r'(\d+(?:,\d{3})*(?:\.\d{2})?)\s*(?:元|人民币|rmb|¥)', 'CNY'),
-            # 英镑
             (r'(\d+(?:,\d{3})*(?:\.\d{2})?)\s*(?:英镑|pounds?|gbp|£)', 'GBP'),
         ]
         
@@ -90,11 +102,12 @@ class InfoExtractor:
             if match:
                 amount_str = match.group(1).replace(',', '')
                 amount = float(amount_str)
+                log.info(f"✅ 匹配到金额: {amount}{currency}")
                 return {
                     'amount': amount,
                     'currency': currency,
                     'type': self._categorize_budget_amount(amount, currency),
-                    'description': f"{amount}{currency}"
+                    'description': f"{int(amount)}{currency}"
                 }
         
         # 2. 匹配预算类型关键词
@@ -107,26 +120,19 @@ class InfoExtractor:
         for budget_type, keywords in budget_keywords.items():
             for keyword in keywords:
                 if keyword in message_lower:
+                    log.info(f"✅ 匹配到预算类型: '{keyword}' -> {budget_type}")
                     return {
                         'type': budget_type,
                         'description': self._get_budget_type_description(budget_type)
                     }
         
+        log.info("❌ 未匹配到任何预算信息")
         return None
     
+    # 其他方法保持不变
     def _categorize_budget_amount(self, amount: float, currency: str) -> str:
-        """根据金额和货币分类预算类型"""
-        # 将所有货币转换为欧元基准进行分类
-        eur_rates = {
-            'EUR': 1.0,
-            'USD': 0.85,  # 1 USD ≈ 0.85 EUR
-            'CNY': 0.13,  # 1 CNY ≈ 0.13 EUR
-            'GBP': 1.15   # 1 GBP ≈ 1.15 EUR
-        }
-        
+        eur_rates = {'EUR': 1.0, 'USD': 0.85, 'CNY': 0.13, 'GBP': 1.15}
         eur_amount = amount * eur_rates.get(currency, 1.0)
-        
-        # 按每日预算分类（假设7天行程）
         daily_budget = eur_amount / 7
         
         if daily_budget < 50:
@@ -137,7 +143,6 @@ class InfoExtractor:
             return 'luxury'
     
     def _get_budget_type_description(self, budget_type: str) -> str:
-        """获取预算类型的描述"""
         descriptions = {
             'economy': '经济型预算',
             'comfortable': '舒适型预算',

modules/response_generator.py

@@ -1,8 +1,6 @@
-# modules/response_generator.py - 完整版本（含persona+预算）
 import json
 import os
 from .ai_model import AIModel
-from pathlib import Path
 from .knowledge_base import KnowledgeBase
 from utils.logger import log
 
@@ -14,184 +12,174 @@ class ResponseGenerator:
 
     def _load_personas(self):
         """加载personas配置"""
-        personas_path = Path("./config/personas.json")
+        personas_path = "./config/personas.json"  # 简化路径
         with open(personas_path, 'r', encoding='utf-8') as f:
             data = json.load(f)
             return data.get('personas', {})
 
     def generate(self, user_message: str, session_state: dict, extracted_info: dict) -> str:
-        """
-        生成智能响应。
-        这个方法现在更加灵活，能够处理信息的修改，并按优先级提问。
-
-        Args:
-            user_message (str): 用户的原始消息。
-            session_state (dict): 当前完整的会话状态。
-            extracted_info (dict): 从当前用户消息中新提取的信息。
-        """
+        """生成智能响应 - 修复重复询问问题"""
         try:
             response_parts = []
 
-            # 1. (新增) 生成对新提取信息的确认反馈
-            #    这是解决“修改信息”问题的关键。
+            # 1. 生成对新提取信息的确认反馈
             acknowledgement = self._generate_acknowledgement(extracted_info)
             if acknowledgement:
                 response_parts.append(acknowledgement)
 
-            # 2. 按优先级检查缺失信息，并生成下一个问题
-            #    这个结构取代了之前僵硬的if-if-if流程。
-            if not session_state.get("destination"):
-                question = "Hi！你想去欧洲的哪个城市呢？比如巴黎, 罗马, 巴塞罗那？"
-                response_parts.append(question)
-            
-            elif not session_state.get("duration"):
-                question = f"好的，{session_state['destination']['name']}是个很棒的选择！你计划玩几天呢？"
-                response_parts.append(question)
-
-            elif not session_state.get("budget"):
-                question = f"了解！{session_state['duration']['days']}天的行程。为了给您更合适的建议，请问您的预算大概是多少呢？（比如：2000欧元，或经济型/舒适型/豪华型）"
-                response_parts.append(question)
-            
-            elif not session_state.get("persona"):
-                separator = '*' * 60
-    
-                question = f"""请告诉我您更偏向哪种旅行风格：高效规划型、社交分享型，还是深度体验型？
-
-        {separator}
-
-        🗓️ **高效规划型** - 注重时间安排和预算控制，喜欢详细的行程规划
+            # 2. 检查信息完整性，按优先级询问缺失信息
+            next_question = self._get_next_question(session_state)
+            if next_question:
+                response_parts.append(next_question)
 
-        🤝 **社交分享型** - 重视与朋友分享，喜欢拍照打卡和热闹的体验
-
-        🎨 **深度体验型** - 追求地道文化体验，避开商业化景点"""
-                response_parts.append(question)
-            
-            else:
-                # 3. 如果所有信息都已收集完毕，则生成最终的旅行计划
-                #    如果刚才有信息修改，确认信息会和最终计划一起发出。
+            # 3. 如果所有信息都齐全，生成旅行计划
+            if not next_question:
                 plan = self._generate_persona_enhanced_plan(user_message, session_state)
                 response_parts.append(plan)
             
-            # 将确认信息和下一个问题（或最终计划）组合成一句通顺的回复
-            return " ".join(response_parts)
+            # 组合回复
+            return " ".join(response_parts) if response_parts else "我理解了，请继续告诉我您的需求。"
         
         except Exception as e:
             log.error(f"❌ 响应生成失败: {e}", exc_info=True)
             return "抱歉，我在处理您的请求时遇到了问题，请稍后再试。"
 
+    def _get_next_question(self, session_state: dict) -> str:
+        """获取下一个需要询问的问题 - 修复版"""
+        
+        # 按顺序检查缺失信息
+        if not session_state.get("destination"):
+            return "你想去欧洲的哪个城市呢？比如巴黎、罗马、巴塞罗那？"
+        
+        if not session_state.get("duration"):
+            destination_name = session_state.get('destination', {}).get('name', '目的地')
+            return f"好的，{destination_name}是个很棒的选择！你计划玩几天呢？"
+        
+        if not session_state.get("budget"):
+            days = session_state.get('duration', {}).get('days', '几')
+            return f"了解！{days}天的行程。预算大概多少呢？（比如：2000欧元，或经��型/舒适型/豪华型）"
+        
+        if not session_state.get("persona"):
+            return """请选择您的旅行风格：
+
+🗓️ **高效规划型** - 注重时间安排和预算控制
+🤝 **社交分享型** - 重视拍照打卡和分享体验  
+🎨 **深度体验型** - 追求地道文化和小众探索"""
+        
+        # 所有信息都已收集完毕
+        return ""
+
     def _generate_acknowledgement(self, extracted_info: dict) -> str:
-        """
-        (新增) 为新提取的信息生成确认语。
-        例如，如果用户修改了天数，会返回 "好的，已将行程天数更新为5天。"
-        """
+        """生成确认信息 - 简化版"""
+        if not extracted_info:
+            return ""
+        
         ack_parts = []
+        
         if "destination" in extracted_info:
-            ack_parts.append(f"目的地已更新为“{extracted_info['destination']['name']}”")
+            name = extracted_info['destination'].get('name', '目的地')
+            ack_parts.append(f"目的地已设置为{name}")
+        
         if "duration" in extracted_info:
-            ack_parts.append(f"行程天数已更新为“{extracted_info['duration']['description']}”")
+            days = extracted_info['duration'].get('days', '几')
+            ack_parts.append(f"行程天数已设置为{days}天")
+        
         if "budget" in extracted_info:
-            ack_parts.append(f"预算已更新为“{self._format_budget_info(extracted_info['budget'])}”")
-        if "persona" in extracted_info:
-            ack_parts.append(f"旅行风格已确认为“{extracted_info['persona']['description']}”")
-
+            budget_desc = self._format_budget_info(extracted_info['budget'])
+            ack_parts.append(f"预算已设置为{budget_desc}")
+        
         if not ack_parts:
             return ""
         
         return "好的，" + "，".join(ack_parts) + "。"
 
     def _generate_persona_enhanced_plan(self, user_message: str, session_state: dict) -> str:
-        """根据persona和完整信息生成定制化的旅行计划"""
-
-        search_query = self._build_search_query(session_state)
-        relevant_knowledge = self.kb.search(search_query)
-        knowledge_context = self._format_knowledge_context(relevant_knowledge)
-
-        persona_prompt = self._build_persona_enhanced_prompt(session_state, knowledge_context)
+        """生成最终旅行计划"""
+        
+        # 获取基本信息
+        destination = session_state.get("destination", {})
+        duration = session_state.get("duration", {})
+        budget = session_state.get("budget", {})
+        persona = session_state.get("persona", {})
         
-        # 3. 使用AI生成回答
+        # 构建计划
+        location = destination.get('name', '目的地')
+        days = duration.get('days', '几')
+        budget_info = self._format_budget_info(budget)
+        persona_name = persona.get('name', '旅行者')
+        
+        # 如果AI可用，生成详细计划
         if self.ai_model.is_available():
-            return self.ai_model.generate(user_message, persona_prompt)
+            prompt = self._build_prompt(session_state)
+            return self.ai_model.generate(user_message, prompt)
         else:
-            return self._generate_fallback_plan(session_state, knowledge_context)
+            # 备用计划
+            return f"""✈️ 为您制定{location}{days}天旅行计划
+
+👤 旅行风格：{persona_name}
+💰 预算：{budget_info}
 
-    def _build_persona_enhanced_prompt(self, session_state: dict, knowledge_context: str = "") -> str:
-        """根据persona构建增强的prompt"""
+🎯 主要景点：{destination.get('highlights', '经典景点等您探索')}
+
+📍 建议路线：根据您的{persona_name}风格，为您推荐最适合的行程安排。
+
+如需详细规划，请稍后重试或告诉我具体需求！"""
+
+    def _build_prompt(self, session_state: dict) -> str:
+        """构建AI提示词"""
         destination = session_state.get("destination", {})
         duration = session_state.get("duration", {})
         budget = session_state.get("budget", {})
         persona = session_state.get("persona", {})
         
-        # 基础信息
         location = destination.get('name', '目的地')
         days = duration.get('days', '几')
         budget_info = self._format_budget_info(budget)
         
-        # 获取persona配置
-        persona_key = persona.get('key')
-        if not persona_key or persona_key not in self.personas:
-            # 如果没有有效persona，使用通用prompt
-            return self._build_generic_prompt(session_state, knowledge_context)
-        
-        persona_config = self.personas[persona_key]
-        
-        # 使用personas.json中的prompt_template
-        persona_template = persona_config.get('prompt_template', '')
-        
-        # 替换模板中的变量
-        enhanced_prompt = persona_template.format(
-            location=location,
-            days=days,
-            date="近期",  # 可以从session中获取更具体的日期
-            user_tags="",  # 可以从用户偏好中提取
-            commercial_preference="适中",  # 可以从session中获取
-            group_description="个人/朋友",  # 可以从session中获取
-            budget=budget_info,  # 使用格式化的预算信息
-            tags=""  # 可以从session中获取
-        )
-        
-        # 添加知识库上下文
-        if knowledge_context:
-            enhanced_prompt += f"\n\n【背景知识】\n{knowledge_context}"
-        
-        # 添加预算约束信息
-        enhanced_prompt += f"\n\n【预算约束】\n用户预算：{budget_info}，请确保所有推荐都在预算范围内。"
+        # 基础prompt
+        prompt = f"请为{location}制定{days}天旅行计划，预算{budget_info}。"
         
-        # 添加persona特定的指导原则
-        characteristics = persona_config.get('characteristics', [])
-        if characteristics:
-            enhanced_prompt += f"\n\n【用户特征】\n" + "\n".join([f"- {char}" for char in characteristics])
-        
-        recommendation_strategy = persona_config.get('recommendation_strategy', [])
-        if recommendation_strategy:
-            enhanced_prompt += f"\n\n【推荐策略】\n" + "\n".join([f"- {strategy}" for strategy in recommendation_strategy])
-        
-        tone_guidelines = persona_config.get('tone', [])
-        if tone_guidelines:
-            enhanced_prompt += f"\n\n【语言风格】\n" + "\n".join([f"- {tone}" for tone in tone_guidelines])
+        # 添加persona风格
+        persona_key = persona.get('key')
+        if persona_key in self.personas:
+            persona_config = self.personas[persona_key]
+            template = persona_config.get('prompt_template', '')
+            if template:
+                try:
+                    prompt = template.format(
+                        location=location,
+                        days=days,
+                        budget=budget_info,
+                        date="近期",
+                        user_tags="",
+                        commercial_preference="适中",
+                        group_description="个人",
+                        tags=""
+                    )
+                except:
+                    # 如果模板格式化失败，使用基础prompt
+                    pass
         
-        return enhanced_prompt
+        return prompt
 
     def _format_budget_info(self, budget: dict) -> str:
         """格式化预算信息"""
         if not budget:
             return "中等预算"
         
-        # 如果有具体金额
         if budget.get('amount') and budget.get('currency'):
             return f"{budget['amount']}{budget['currency']}"
         
-        # 如果有预算类型
+        if budget.get('description'):
+            return budget['description']
+        
         if budget.get('type'):
-            budget_type_map = {
-                'economy': '经济型预算',
-                'comfortable': '舒适型预算', 
-                'luxury': '豪华型预算'
+            type_map = {
+                'economy': '经济型',
+                'comfortable': '舒适型', 
+                'luxury': '豪华型'
             }
-            return budget_type_map.get(budget['type'], budget['type'])
-        
-        # 如果有预算范围
-        if budget.get('range'):
-            return budget['range']
+            return type_map.get(budget['type'], budget['type'])
         
         return "中等预算"