jarvis-ai-assistant 0.7.0__py3-none-any.whl → 0.7.8__py3-none-any.whl

jarvis/jarvis_code_agent/code_analyzer/llm_context_recommender.py

@@ -5,13 +5,14 @@
 """
 
 
+from jarvis.jarvis_utils.jsonnet_compat import loads as json_loads
+import json
 import os
 import re
-import yaml
-from typing import List, Optional, Dict, Any, Set
+from typing import List, Optional, Any
 
+from rich.console import Console
 from jarvis.jarvis_platform.registry import PlatformRegistry
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.config import get_normal_platform_name, get_normal_model_name
 from jarvis.jarvis_code_agent.utils import get_project_overview
 
@@ -60,6 +61,7 @@ class ContextRecommender:
             
             # 优先根据 model_group 获取配置（确保配置一致性）
             # 如果 model_group 存在，强制使用它来解析，避免使用 parent_model 中可能不一致的值
+            # 使用cheap平台，上下文推荐可以降低成本
             if model_group:
                 try:
                     platform_name = get_normal_platform_name(model_group)
@@ -72,10 +74,10 @@ class ContextRecommender:
             if platform_name:
                 self.llm_model = registry.create_platform(platform_name)
                 if self.llm_model is None:
-                    # 如果创建失败，使用默认平台
-                    self.llm_model = registry.get_normal_platform()
+                    # 如果创建失败，使用cheap平台
+                    self.llm_model = registry.get_cheap_platform()
             else:
-                self.llm_model = registry.get_normal_platform()
+                self.llm_model = registry.get_cheap_platform()
             
             # 先设置模型组（如果从父Agent获取到），因为 model_group 可能会影响模型名称的解析
             if model_group and self.llm_model:
@@ -111,37 +113,66 @@ class ContextRecommender:
         Returns:
             ContextRecommendation: 推荐的上下文信息
         """
-        # 1. 使用LLM提取关键词（仅提取关键词）
-        keywords = self._extract_keywords_with_llm(user_input)
+        print("🔍 开始智能上下文推荐分析...")
+        
+        # 0. 检查并填充符号表（如果为空）
+        self._ensure_symbol_table_loaded()
+        
+        # 1. 使用LLM生成相关符号名
+        model_name = self.llm_model.name() if self.llm_model else "LLM"
+        print(f"📝 正在使用{model_name}生成相关符号名...")
+        symbol_names = self._extract_symbol_names_with_llm(user_input)
+        if symbol_names:
+            print(f"✅ 生成 {len(symbol_names)} 个符号名: {', '.join(symbol_names[:5])}{'...' if len(symbol_names) > 5 else ''}")
+        else:
+            print("⚠️ 未能生成符号名，将使用基础搜索策略")
         
         # 2. 初始化推荐结果
         recommended_symbols: List[Symbol] = []
 
-        # 3. 基于关键词进行符号查找和文本查找，然后使用LLM挑选关联度高的条目（主要推荐方式）
-        if keywords:
-            # 3.1 使用关键词进行符号查找和文本查找，找到所有候选符号及其位置
-            candidate_symbols = self._search_symbols_by_keywords(keywords)
-            candidate_symbols_from_text = self._search_text_by_keywords(keywords)
+        # 3. 基于符号名进行符号查找，然后使用LLM挑选关联度高的条目（主要推荐方式）
+        if symbol_names:
+            # 3.1 使用符号名进行精确查找，找到所有候选符号及其位置
+            print("🔎 正在基于符号名搜索相关符号...")
+            candidate_symbols = self._search_symbols_by_names(symbol_names)
             
-            # 合并候选符号（去重）
-            all_candidates = {}
-            for symbol in candidate_symbols + candidate_symbols_from_text:
-                # 使用 (file_path, name, line_start) 作为唯一键
-                key = (symbol.file_path, symbol.name, symbol.line_start)
-                if key not in all_candidates:
-                    all_candidates[key] = symbol
+            print(f"📊 符号名匹配: {len(candidate_symbols)} 个候选")
             
-            candidate_symbols_list = list(all_candidates.values())
+            candidate_symbols_list = candidate_symbols
+            print(f"📦 共 {len(candidate_symbols_list)} 个候选符号")
             
             # 3.2 使用LLM从候选符号中挑选关联度高的条目
             if candidate_symbols_list:
+                model_name = self.llm_model.name() if self.llm_model else "LLM"
+                print(f"🤖 正在使用{model_name}从 {len(candidate_symbols_list)} 个候选符号中筛选最相关的条目...")
                 selected_symbols = self._select_relevant_symbols_with_llm(
-                    user_input, keywords, candidate_symbols_list
+                    user_input, symbol_names, candidate_symbols_list
                 )
                 recommended_symbols.extend(selected_symbols)
-
-        # 4. 限制符号数量
-        final_symbols = recommended_symbols[:10]
+                print(f"✅ {model_name}筛选完成，选中 {len(selected_symbols)} 个相关符号")
+            else:
+                print("⚠️ 没有找到候选符号")
+        else:
+            print("⚠️ 无符号名可用，跳过符号推荐")
+
+        # 4. 对推荐符号去重（基于 name + file_path + line_start）
+        seen = set()
+        unique_symbols = []
+        for symbol in recommended_symbols:
+            key = (symbol.name, symbol.file_path, symbol.line_start)
+            if key not in seen:
+                seen.add(key)
+                unique_symbols.append(symbol)
+       
+        if len(unique_symbols) < len(recommended_symbols):
+            print(f"🔄 去重: {len(recommended_symbols)} -> {len(unique_symbols)} 个符号")
+       
+        # 5. 限制符号数量
+        final_symbols = unique_symbols[:10]
+        if len(unique_symbols) > 10:
+            print(f"📌 推荐结果已限制为前 10 个符号（共 {len(unique_symbols)} 个）")
+
+        print(f"✨ 上下文推荐完成，共推荐 {len(final_symbols)} 个符号")
 
         return ContextRecommendation(
             recommended_symbols=final_symbols,
@@ -155,166 +186,274 @@ class ContextRecommender:
         """
         return get_project_overview(self.context_manager.project_root)
 
-    def _extract_keywords_with_llm(self, user_input: str) -> List[str]:
-        """使用LLM提取关键词（仅提取关键词）
+    def _ensure_symbol_table_loaded(self) -> None:
+        """确保符号表已加载（如果为空则扫描项目文件）
+        
+        在推荐上下文之前，需要确保符号表已经被填充。
+        如果符号表为空，则扫描项目文件并填充符号表。
+        """
+        # 检查符号表是否为空
+        if not self.context_manager.symbol_table.symbols_by_name:
+            print("📚 符号表为空，开始扫描项目文件构建符号表...")
+            self._build_symbol_table()
+        else:
+            symbol_count = sum(len(symbols) for symbols in self.context_manager.symbol_table.symbols_by_name.values())
+            print(f"📚 符号表已就绪，包含 {symbol_count} 个符号")
+
+    def _build_symbol_table(self) -> None:
+        """扫描项目文件并构建符号表
+        
+        遍历项目目录，提取所有支持语言的符号。
+        """
+        import os
+        from .language_support import detect_language, get_symbol_extractor
+        from .file_ignore import filter_walk_dirs
+        
+        console = Console()
+        project_root = self.context_manager.project_root
+        files_scanned = 0
+        symbols_added = 0
+        files_with_symbols = 0
+        files_skipped = 0
+        
+        # 用于清除行的最大宽度（终端通常80-120字符，使用100作为安全值）
+        max_line_width = 100
+        
+        # 快速统计总文件数（用于进度显示）
+        console.print("📊 正在统计项目文件...", end="")
+        total_files = 0
+        for root, dirs, files in os.walk(project_root):
+            dirs[:] = filter_walk_dirs(dirs)
+            for file in files:
+                file_path = os.path.join(root, file)
+                language = detect_language(file_path)
+                if language and get_symbol_extractor(language):
+                    total_files += 1
+        console.print(" 完成")  # 统计完成，换行
+        
+        # 进度反馈间隔（每处理这么多文件输出一次，最多每10个文件输出一次）
+        # progress_interval = max(1, min(total_files // 20, 10)) if total_files > 0 else 10
+        
+        if total_files > 0:
+            console.print(f"📁 发现 {total_files} 个代码文件，开始扫描...")
+        else:
+            console.print("⚠️  未发现可扫描的代码文件", style="yellow")
+            return
+        
+        # 辅助函数：生成固定宽度的进度字符串（避免残留字符）
+        def format_progress_msg(current_file: str, scanned: int, total: int, symbols: int, skipped: int) -> str:
+            progress_pct = (scanned * 100) // total if total > 0 else 0
+            base_msg = f"⏳ 扫描进度: {scanned}/{total} ({progress_pct}%)"
+            if symbols > 0:
+                base_msg += f"，已提取 {symbols} 个符号"
+            if skipped > 0:
+                base_msg += f"，跳过 {skipped}"
+            base_msg += f" | {current_file}"
+            # 填充空格到固定宽度，清除旧内容
+            if len(base_msg) < max_line_width:
+                base_msg += " " * (max_line_width - len(base_msg))
+            return base_msg
+        
+        # 遍历项目目录
+        for root, dirs, files in os.walk(project_root):
+            # 过滤需要忽略的目录
+            dirs[:] = filter_walk_dirs(dirs)
+            
+            for file in files:
+                file_path = os.path.join(root, file)
+                
+                # 检测语言
+                language = detect_language(file_path)
+                if not language:
+                    continue
+                
+                # 获取符号提取器
+                extractor = get_symbol_extractor(language)
+                if not extractor:
+                    continue
+                
+                # 获取相对路径用于显示（限制长度）
+                try:
+                    rel_path = os.path.relpath(file_path, project_root)
+                    # 如果路径太长，只显示文件名
+                    if len(rel_path) > 40:
+                        rel_path = "..." + rel_path[-37:]
+                except Exception:
+                    rel_path = file
+                
+                # 读取文件内容（跳过超大文件，避免内存问题）
+                try:
+                    # 检查文件大小（超过 1MB 的文件跳过）
+                    file_size = os.path.getsize(file_path)
+                    if file_size > 1024 * 1024:  # 1MB
+                        files_skipped += 1
+                        # 实时更新进度（不换行，文件名在最后）
+                        msg = format_progress_msg(rel_path, files_scanned, total_files, symbols_added, files_skipped)
+                        console.print(msg, end="\r")
+                        continue
+                    
+                    # 显示当前正在扫描的文件
+                    msg = format_progress_msg(rel_path, files_scanned, total_files, symbols_added, files_skipped)
+                    console.print(msg, end="\r")
+                    
+                    with open(file_path, 'r', encoding='utf-8', errors='replace') as f:
+                        content = f.read()
+                    if not content:
+                        continue
+                    
+                    # 提取符号
+                    symbols = extractor.extract_symbols(file_path, content)
+                    if symbols:
+                        files_with_symbols += 1
+                    for symbol in symbols:
+                        # 不立即保存缓存，批量添加以提高性能
+                        self.context_manager.symbol_table.add_symbol(symbol, save_to_cache=False)
+                        symbols_added += 1
+                    
+                    # 更新文件修改时间
+                    try:
+                        self.context_manager.symbol_table._file_mtimes[file_path] = os.path.getmtime(file_path)
+                    except Exception:
+                        pass
+                    
+                    files_scanned += 1
+                    
+                    # 实时更新进度（不换行，文件名在最后）
+                    msg = format_progress_msg(rel_path, files_scanned, total_files, symbols_added, files_skipped)
+                    console.print(msg, end="\r")
+                except Exception:
+                    # 跳过无法读取的文件
+                    files_skipped += 1
+                    # 实时更新进度（不换行，文件名在最后）
+                    msg = format_progress_msg(rel_path, files_scanned, total_files, symbols_added, files_skipped)
+                    console.print(msg, end="\r")
+                    continue
+        
+        # 完成时显示100%进度，然后换行并显示最终结果
+        if total_files > 0:
+            # 清除进度行
+            console.print(" " * max_line_width, end="\r")
+        console.print()  # 换行
+        
+        # 批量保存缓存（扫描完成后一次性保存，提高性能）
+        try:
+            console.print("💾 正在保存符号表缓存...", end="\r")
+            self.context_manager.symbol_table.save_cache()
+            console.print("💾 符号表缓存已保存")
+        except Exception as e:
+            console.print(f"⚠️  保存符号表缓存失败: {e}", style="yellow")
+        
+        skip_msg = f"，跳过 {files_skipped} 个文件" if files_skipped > 0 else ""
+        console.print(
+            f"✅ 符号表构建完成: 扫描 {files_scanned} 个文件{skip_msg}，提取 {symbols_added} 个符号（来自 {files_with_symbols} 个文件）",
+            style="green"
+        )
+
+    def _extract_symbol_names_with_llm(self, user_input: str) -> List[str]:
+        """使用LLM生成相关符号名
         
         Args:
             user_input: 用户输入
             
         Returns:
-            关键词列表
+            符号名列表
         """
-        # 获取项目概况
+        # 获取项目概况和符号表信息
         project_overview = self._get_project_overview()
         
-        prompt = f"""分析以下代码编辑任务，提取关键词。关键词应该是与任务相关的核心概念、技术术语、功能模块等。
+        # 获取所有可用的符号名（用于参考）
+        all_symbol_names = list(self.context_manager.symbol_table.symbols_by_name.keys())
+        symbol_names_sample = sorted(all_symbol_names)[:50]  # 取前50个作为示例
+        
+        prompt = f"""分析代码编辑任务，生成5-15个可能相关的符号名（函数名、类名、变量名等）。
 
 {project_overview}
 
-任务描述：
-{user_input}
+任务描述：{user_input}
+
+符号名示例：{', '.join(symbol_names_sample[:30])}{'...' if len(symbol_names_sample) > 30 else ''}
 
-请提取5-10个关键词，以YAML数组格式返回，并用<KEYWORDS>标签包裹。
-只返回关键词数组，不要包含其他文字。
+要求：与任务直接相关，符合命名规范，尽量具体。
 
-示例格式：
-<KEYWORDS>
-- data processing
-- validation
-- error handling
-- API endpoint
-- authentication
-</KEYWORDS>
+以Jsonnet数组格式返回，用<SYMBOL_NAMES>标签包裹。示例：
+<SYMBOL_NAMES>
+["processData", "validateInput", "handleError"]
+</SYMBOL_NAMES>
 """
 
         try:
             response = self._call_llm(prompt)
-            # 从<KEYWORDS>标签中提取内容
+            # 从<SYMBOL_NAMES>标签中提取内容
             response = response.strip()
-            yaml_match = re.search(r'<KEYWORDS>\s*(.*?)\s*</KEYWORDS>', response, re.DOTALL)
-            if yaml_match:
-                yaml_content = yaml_match.group(1).strip()
+            json_match = re.search(r'<SYMBOL_NAMES>\s*(.*?)\s*</SYMBOL_NAMES>', response, re.DOTALL)
+            if json_match:
+                json_content = json_match.group(1).strip()
             else:
                 # 如果没有找到标签，尝试清理markdown代码块
-                if response.startswith("```yaml"):
+                if response.startswith("```json"):
                     response = response[7:]
                 elif response.startswith("```"):
                     response = response[3:]
                 if response.endswith("```"):
                     response = response[:-3]
-                yaml_content = response.strip()
+                json_content = response.strip()
             
-            keywords = yaml.safe_load(yaml_content)
-            if not isinstance(keywords, list):
+            symbol_names = json_loads(json_content)
+            if not isinstance(symbol_names, list):
+                print("⚠️ LLM返回的符号名格式不正确，期望 Jsonnet 数组格式")
                 return []
             
-            # 过滤空字符串和过短的关键词
-            keywords = [k.strip() for k in keywords if k and isinstance(k, str) and len(k.strip()) > 1]
-            return keywords
+            # 过滤空字符串和过短的符号名
+            original_count = len(symbol_names)
+            symbol_names = [name.strip() for name in symbol_names if name and isinstance(name, str) and len(name.strip()) > 0]
+            if original_count != len(symbol_names):
+                print(f"📋 过滤后保留 {len(symbol_names)} 个有效符号名（原始 {original_count} 个）")
+            return symbol_names
         except Exception as e:
             # 解析失败，返回空列表
-            PrettyOutput.print(f"LLM关键词提取失败: {e}", OutputType.WARNING)
+            print(f"❌ LLM符号名生成失败: {e}")
             return []
-
-    def _search_symbols_by_keywords(self, keywords: List[str]) -> List[Symbol]:
-        """基于关键词在符号表中查找相关符号
+    def _search_symbols_by_names(self, symbol_names: List[str]) -> List[Symbol]:
+        """基于符号名在符号表中精确查找相关符号
         
         Args:
-            keywords: 关键词列表
+            symbol_names: 符号名列表
             
         Returns:
             候选符号列表
         """
-        if not keywords:
+        if not symbol_names:
             return []
         
         found_symbols: List[Symbol] = []
-        keywords_lower = [k.lower() for k in keywords]
         found_symbol_keys = set()  # 用于去重，使用 (file_path, name, line_start) 作为键
         
-        # 遍历所有符号，查找名称或签名中包含关键词的符号
+        # 创建符号名映射（支持大小写不敏感匹配）
+        symbol_names_lower = {name.lower(): name for name in symbol_names}
+        
+        # 遍历所有符号，精确匹配符号名
         for symbol_name, symbols in self.context_manager.symbol_table.symbols_by_name.items():
             symbol_name_lower = symbol_name.lower()
             
-            # 检查符号名称是否包含任何关键词
-            name_matched = False
-            for keyword in keywords_lower:
-                if keyword in symbol_name_lower:
-                    # 找到匹配的符号，添加所有同名符号（可能有重载）
-                    for symbol in symbols:
-                        key = (symbol.file_path, symbol.name, symbol.line_start)
-                        if key not in found_symbol_keys:
-                            found_symbols.append(symbol)
-                            found_symbol_keys.add(key)
-                    name_matched = True
-                    break
-            
-            # 如果名称不匹配，检查符号签名是否包含关键词
-            if not name_matched:
+            # 精确匹配：检查符号名是否在目标列表中（大小写不敏感）
+            if symbol_name_lower in symbol_names_lower:
+                # 找到匹配的符号，添加所有同名符号（可能有重载）
                 for symbol in symbols:
-                    if symbol.signature:
-                        signature_lower = symbol.signature.lower()
-                        for keyword in keywords_lower:
-                            if keyword in signature_lower:
-                                key = (symbol.file_path, symbol.name, symbol.line_start)
-                                if key not in found_symbol_keys:
-                                    found_symbols.append(symbol)
-                                    found_symbol_keys.add(key)
-                                break
-        
-        return found_symbols
-
-    def _search_text_by_keywords(self, keywords: List[str]) -> List[Symbol]:
-        """基于关键词在文件内容中进行文本查找，找到相关符号
-        
-        Args:
-            keywords: 关键词列表
-            
-        Returns:
-            候选符号列表（在包含关键词的文件中找到的符号）
-        """
-        if not keywords:
-            return []
-        
-        found_symbols: List[Symbol] = []
-        keywords_lower = [k.lower() for k in keywords]
-        
-        # 获取所有已分析的文件
-        all_files = set()
-        for symbol_name, symbols in self.context_manager.symbol_table.symbols_by_name.items():
-            for symbol in symbols:
-                all_files.add(symbol.file_path)
-        
-        # 在文件内容中搜索关键词
-        for file_path in all_files:
-            content = self.context_manager._get_file_content(file_path)
-            if not content:
-                continue
-            
-            content_lower = content.lower()
-            
-            # 检查文件内容是否包含任何关键词
-            file_matches = False
-            for keyword in keywords_lower:
-                if keyword in content_lower:
-                    file_matches = True
-                    break
-            
-            if file_matches:
-                # 获取该文件中的所有符号
-                file_symbols = self.context_manager.symbol_table.get_file_symbols(file_path)
-                found_symbols.extend(file_symbols)
+                    key = (symbol.file_path, symbol.name, symbol.line_start)
+                    if key not in found_symbol_keys:
+                        found_symbols.append(symbol)
+                        found_symbol_keys.add(key)
         
         return found_symbols
 
     def _select_relevant_symbols_with_llm(
-        self, user_input: str, keywords: List[str], candidate_symbols: List[Symbol]
+        self, user_input: str, symbol_names: List[str], candidate_symbols: List[Symbol]
     ) -> List[Symbol]:
         """使用LLM从候选符号中挑选关联度高的条目
         
         Args:
             user_input: 用户输入/任务描述
-            keywords: 关键词列表
+            symbol_names: 符号名列表
             candidate_symbols: 候选符号列表（包含位置信息）
             
         Returns:
@@ -325,6 +464,8 @@ class ContextRecommender:
         
         # 限制候选符号数量，避免prompt过长
         candidates_to_consider = candidate_symbols[:100]  # 最多100个候选
+        if len(candidate_symbols) > 100:
+            print(f"📌 候选符号数量较多（{len(candidate_symbols)} 个），限制为前 100 个进行LLM筛选")
         
         # 构建带编号的符号信息列表（包含位置信息）
         symbol_info_list = []
@@ -342,25 +483,17 @@ class ContextRecommender:
         # 获取项目概况
         project_overview = self._get_project_overview()
         
-        prompt = f"""根据以下任务描述和关键词，从候选符号列表中选择最相关的符号。
+        prompt = f"""根据任务描述和生成的符号名，从候选符号列表中选择最相关的10-20个符号。
 
 {project_overview}
 
 任务描述：{user_input}
-关键词：{', '.join(keywords)}
-
-候选符号列表（已编号，包含位置信息）：
-{yaml.dump(symbol_info_list, allow_unicode=True, default_flow_style=False)}
-
-请返回最相关的10-20个符号的序号（YAML数组格式），按相关性排序，并用<SELECTED_INDICES>标签包裹。
+生成的符号名：{', '.join(symbol_names)}
+候选符号列表（已编号）：{json.dumps(symbol_info_list, ensure_ascii=False, indent=2)}
 
-只返回序号数组，例如：
+返回最相关符号的序号（Jsonnet数组），按相关性排序，用<SELECTED_INDICES>标签包裹。示例：
 <SELECTED_INDICES>
-- 3
-- 7
-- 12
-- 15
-- 23
+[3, 7, 12, 15, 23]
 </SELECTED_INDICES>
 """
 
@@ -368,35 +501,52 @@ class ContextRecommender:
             response = self._call_llm(prompt)
             # 从<SELECTED_INDICES>标签中提取内容
             response = response.strip()
-            yaml_match = re.search(r'<SELECTED_INDICES>\s*(.*?)\s*</SELECTED_INDICES>', response, re.DOTALL)
-            if yaml_match:
-                yaml_content = yaml_match.group(1).strip()
+            json_match = re.search(r'<SELECTED_INDICES>\s*(.*?)\s*</SELECTED_INDICES>', response, re.DOTALL)
+            if json_match:
+                json_content = json_match.group(1).strip()
             else:
                 # 如果没有找到标签，尝试清理markdown代码块
-                if response.startswith("```yaml"):
+                if response.startswith("```json"):
                     response = response[7:]
                 elif response.startswith("```"):
                     response = response[3:]
                 if response.endswith("```"):
                     response = response[:-3]
-                yaml_content = response.strip()
+                json_content = response.strip()
             
-            selected_indices = yaml.safe_load(yaml_content)
+            selected_indices = json_loads(json_content)
             if not isinstance(selected_indices, list):
+                print("⚠️ LLM返回的符号序号格式不正确，期望 Jsonnet 数组格式")
                 return []
             
+            print(f"📋 LLM返回了 {len(selected_indices)} 个符号序号")
+            
             # 根据序号查找对应的符号对象
             selected_symbols = []
+            invalid_indices = []
             for idx in selected_indices:
                 # 序号从1开始，转换为列表索引（从0开始）
                 if isinstance(idx, int) and 1 <= idx <= len(candidates_to_consider):
                     symbol = candidates_to_consider[idx - 1]
                     selected_symbols.append(symbol)
+                else:
+                    invalid_indices.append(idx)
+            
+            if invalid_indices:
+                print(f"⚠️ 发现 {len(invalid_indices)} 个无效序号: {invalid_indices[:5]}{'...' if len(invalid_indices) > 5 else ''}")
+            
+            if selected_symbols:
+                # 统计选中的符号类型分布
+                kind_count = {}
+                for symbol in selected_symbols:
+                    kind_count[symbol.kind] = kind_count.get(symbol.kind, 0) + 1
+                kind_summary = ", ".join([f"{kind}: {count}" for kind, count in sorted(kind_count.items())])
+                print(f"📊 选中符号类型分布: {kind_summary}")
             
             return selected_symbols
         except Exception as e:
             # 解析失败，返回空列表
-            PrettyOutput.print(f"LLM符号筛选失败: {e}", OutputType.WARNING)
+            print(f"❌ LLM符号筛选失败: {e}")
             return []
 
     def _call_llm(self, prompt: str) -> str:
@@ -415,12 +565,16 @@ class ContextRecommender:
             # 使用chat_until_success方法（BasePlatform的标准接口）
             if hasattr(self.llm_model, 'chat_until_success'):
                 response = self.llm_model.chat_until_success(prompt)
-                return str(response)
+                response_str = str(response)
+                if response_str:
+                    response_length = len(response_str)
+                    print(f"💬 LLM响应长度: {response_length} 字符")
+                return response_str
             else:
                 # 如果不支持chat_until_success，抛出异常
                 raise ValueError("LLM model does not support chat_until_success interface")
         except Exception as e:
-            PrettyOutput.print(f"LLM调用失败: {e}", OutputType.WARNING)
+            print(f"❌ LLM调用失败: {e}")
             raise
 
     def format_recommendation(self, recommendation: ContextRecommendation) -> str: