jarvis-ai-assistant 0.1.110__py3-none-any.whl → 0.1.112__py3-none-any.whl

jarvis/jarvis_codebase/main.py

@@ -37,9 +37,9 @@ class CodeBase:
             self.embedding_model.encode([test_text], 
                                      convert_to_tensor=True,
                                      normalize_embeddings=True)
-            PrettyOutput.print("Model loaded successfully", output_type=OutputType.SUCCESS)
+            PrettyOutput.print("模型加载成功", output_type=OutputType.SUCCESS)
         except Exception as e:
-            PrettyOutput.print(f"Failed to load model: {str(e)}", output_type=OutputType.ERROR)
+            PrettyOutput.print(f"加载模型失败: {str(e)}", output_type=OutputType.ERROR)
             raise
             
         self.vector_dim = self.embedding_model.get_sentence_embedding_dimension()
@@ -71,7 +71,7 @@ class CodeBase:
         if self.thread_count > 1:
             model.set_suppress_output(True)
         else:
-            PrettyOutput.print(f"Make description for {file_path} ...", output_type=OutputType.PROGRESS)
+            PrettyOutput.print(f"为 {file_path} 生成描述 ...", output_type=OutputType.PROGRESS)
         prompt = f"""Please analyze the following code file and generate a detailed description. The description should include:
 1. Overall file functionality description
 2. description for each global variable, function, type definition, class, method, and other code elements
@@ -129,7 +129,7 @@ Code content:
                         self.file_paths.append(file_path)
                         vectors.append(cache_data["vector"])
                 except Exception as e:
-                    PrettyOutput.print(f"Failed to load cache file {cache_file}: {str(e)}", 
+                    PrettyOutput.print(f"加载缓存文件 {cache_file} 失败: {str(e)}", 
                                      output_type=OutputType.WARNING)
                     continue
             
@@ -142,14 +142,14 @@ Code content:
                 self.index = faiss.IndexIDMap(hnsw_index)
                 self.index.add_with_ids(vectors_array, np.array(range(len(vectors)))) # type: ignore
                 
-                PrettyOutput.print(f"Loaded {len(self.vector_cache)} vector cache and rebuilt index", 
+                PrettyOutput.print(f"加载 {len(self.vector_cache)} 个向量缓存并重建索引", 
                                  output_type=OutputType.INFO)
             else:
                 self.index = None
-                PrettyOutput.print("No valid cache files found", output_type=OutputType.WARNING)
+                PrettyOutput.print("没有找到有效的缓存文件", output_type=OutputType.WARNING)
                 
         except Exception as e:
-            PrettyOutput.print(f"Failed to load cache directory: {str(e)}", 
+            PrettyOutput.print(f"加载缓存目录失败: {str(e)}", 
                              output_type=OutputType.WARNING)
             self.vector_cache = {}
             self.file_paths = []
@@ -161,7 +161,7 @@ Code content:
             with open(file_path, "rb") as f:
                 file_md5 = hashlib.md5(f.read()).hexdigest()
         except Exception as e:
-            PrettyOutput.print(f"Failed to calculate MD5 for {file_path}: {str(e)}", 
+            PrettyOutput.print(f"计算 {file_path} 的MD5失败: {str(e)}", 
                               output_type=OutputType.ERROR)
             file_md5 = ""
         
@@ -182,7 +182,7 @@ Code content:
             with lzma.open(cache_path, 'wb') as f:
                 pickle.dump(cache_data, f, protocol=pickle.HIGHEST_PROTOCOL)
         except Exception as e:
-            PrettyOutput.print(f"Failed to save cache for {file_path}: {str(e)}", 
+            PrettyOutput.print(f"保存 {file_path} 的缓存失败: {str(e)}", 
                              output_type=OutputType.ERROR)
 
     def get_cached_vector(self, file_path: str, description: str) -> Optional[np.ndarray]:
@@ -195,7 +195,7 @@ Code content:
             with open(file_path, "rb") as f:
                 current_md5 = hashlib.md5(f.read()).hexdigest()
         except Exception as e:
-            PrettyOutput.print(f"Failed to calculate MD5 for {file_path}: {str(e)}", 
+            PrettyOutput.print(f"计算 {file_path} 的MD5失败: {str(e)}", 
                               output_type=OutputType.ERROR)
             return None
         
@@ -232,7 +232,7 @@ Content: {content}
             self.cache_vector(file_path, vector, description)
             return vector
         except Exception as e:
-            PrettyOutput.print(f"Error vectorizing file {file_path}: {str(e)}", 
+            PrettyOutput.print(f"向量化 {file_path} 失败: {str(e)}", 
                              output_type=OutputType.ERROR)
             return np.zeros(self.vector_dim, dtype=np.float32) # type: ignore
 
@@ -257,7 +257,7 @@ Content: {content}
             return bool(files_to_delete)
             
         except Exception as e:
-            PrettyOutput.print(f"Failed to clean cache: {str(e)}", 
+            PrettyOutput.print(f"清理缓存失败: {str(e)}", 
                              output_type=OutputType.ERROR)
             return False
 
@@ -293,7 +293,7 @@ Content: {content}
             return file_path
             
         except Exception as e:
-            PrettyOutput.print(f"Failed to process file {file_path}: {str(e)}", 
+            PrettyOutput.print(f"处理 {file_path} 失败: {str(e)}", 
                              output_type=OutputType.ERROR)
             return None
 
@@ -318,13 +318,13 @@ Content: {content}
             
             for i, (file_path, data) in enumerate(self.vector_cache.items()):
                 if "vector" not in data:
-                    PrettyOutput.print(f"Invalid cache data for {file_path}: missing vector", 
+                    PrettyOutput.print(f"无效的缓存数据 {file_path}: 缺少向量", 
                                      output_type=OutputType.WARNING)
                     continue
                     
                 vector = data["vector"]
                 if not isinstance(vector, np.ndarray):
-                    PrettyOutput.print(f"Invalid vector type for {file_path}: {type(vector)}", 
+                    PrettyOutput.print(f"无效的向量类型 {file_path}: {type(vector)}", 
                                      output_type=OutputType.WARNING)
                     continue
                     
@@ -335,26 +335,26 @@ Content: {content}
             if vectors:
                 vectors = np.vstack(vectors)
                 if len(vectors) != len(ids):
-                    PrettyOutput.print(f"Vector count mismatch: {len(vectors)} vectors vs {len(ids)} ids", 
+                    PrettyOutput.print(f"向量数量不匹配: {len(vectors)} 个向量 vs {len(ids)} 个ID", 
                                      output_type=OutputType.ERROR)
                     self.index = None
                     return
                     
                 try:
                     self.index.add_with_ids(vectors, np.array(ids)) # type: ignore
-                    PrettyOutput.print(f"Successfully built index with {len(vectors)} vectors", 
+                    PrettyOutput.print(f"成功构建包含 {len(vectors)} 个向量的索引", 
                                      output_type=OutputType.SUCCESS)
                 except Exception as e:
-                    PrettyOutput.print(f"Failed to add vectors to index: {str(e)}", 
+                    PrettyOutput.print(f"添加向量到索引失败: {str(e)}", 
                                      output_type=OutputType.ERROR)
                     self.index = None
             else:
-                PrettyOutput.print("No valid vectors found, index not built", 
+                PrettyOutput.print("没有找到有效的向量, 索引未构建", 
                                  output_type=OutputType.WARNING)
                 self.index = None
                 
         except Exception as e:
-            PrettyOutput.print(f"Failed to build index: {str(e)}", 
+            PrettyOutput.print(f"构建索引失败: {str(e)}", 
                              output_type=OutputType.ERROR)
             self.index = None
 
@@ -379,20 +379,20 @@ Content: {content}
                     try:
                         os.remove(cache_path)
                     except Exception as e:
-                        PrettyOutput.print(f"Failed to delete cache file for {cached_file}: {str(e)}", 
+                        PrettyOutput.print(f"删除缓存文件 {cached_file} 失败: {str(e)}", 
                                          output_type=OutputType.WARNING)
             
             if files_to_delete:
                 for file_path in files_to_delete:
                     del self.vector_cache[file_path]
-                PrettyOutput.print(f"Cleaned cache for {len(files_to_delete)} non-existent files", 
+                PrettyOutput.print(f"清理了 {len(files_to_delete)} 个不存在的文件的缓存", 
                                  output_type=OutputType.INFO)
             
             # Update the git file list
             self.git_file_list = self.get_git_file_list()
             
             # Check file changes
-            PrettyOutput.print("Check file changes...", output_type=OutputType.INFO)
+            PrettyOutput.print("检查文件变化...", output_type=OutputType.INFO)
             changes_detected = False
             new_files = []
             modified_files = []
@@ -424,36 +424,36 @@ Content: {content}
                             modified_files.append(file_path)
                             changes_detected = True
                     except Exception as e:
-                        PrettyOutput.print(f"Failed to check file {file_path}: {str(e)}", 
+                        PrettyOutput.print(f"检查 {file_path} 失败: {str(e)}", 
                                          output_type=OutputType.ERROR)
                     progress.advance(task)
             
             # If changes are detected, display changes and ask the user
             if changes_detected:
-                output_lines = ["Detected the following changes:"]
+                output_lines = ["检测到以下变化:"]
                 if new_files:
-                    output_lines.append("New files:")
+                    output_lines.append("新文件:")
                     output_lines.extend(f"  {f}" for f in new_files)
                 if modified_files:
-                    output_lines.append("Modified files:")
+                    output_lines.append("修改的文件:")
                     output_lines.extend(f"  {f}" for f in modified_files)
                 if deleted_files:
-                    output_lines.append("Deleted files:")
+                    output_lines.append("删除的文件:")
                     output_lines.extend(f"  {f}" for f in deleted_files)
                 
                 PrettyOutput.print("\n".join(output_lines), output_type=OutputType.WARNING)
 
                 # If force is True, continue directly
                 if not force:
-                    if not user_confirm("Rebuild the index?", False):
-                        PrettyOutput.print("Cancel rebuilding the index", output_type=OutputType.INFO)
+                    if not user_confirm("重建索引?", False):
+                        PrettyOutput.print("取消重建索引", output_type=OutputType.INFO)
                         return
                 
                 # Clean deleted files
                 for file_path in files_to_delete:
                     del self.vector_cache[file_path]
                 if files_to_delete:
-                    PrettyOutput.print(f"Cleaned the cache of {len(files_to_delete)} files", 
+                    PrettyOutput.print(f"清理了 {len(files_to_delete)} 个文件的缓存", 
                                      output_type=OutputType.INFO)
                 
                 # Process new and modified files
@@ -482,19 +482,19 @@ Content: {content}
                             pbar.update(1)
 
                 if processed_files:
-                    PrettyOutput.print("Rebuilding the vector database...", output_type=OutputType.INFO)
+                    PrettyOutput.print("重建向量数据库...", output_type=OutputType.INFO)
                     self.gen_vector_db_from_cache()
-                    PrettyOutput.print(f"Successfully generated the index for {len(processed_files)} files", 
+                    PrettyOutput.print(f"成功生成了 {len(processed_files)} 个文件的索引", 
                                     output_type=OutputType.SUCCESS)
             else:
-                PrettyOutput.print("No file changes detected, no need to rebuild the index", output_type=OutputType.INFO)
+                PrettyOutput.print("没有检测到文件变化, 不需要重建索引", output_type=OutputType.INFO)
                 
         except Exception as e:
             # Try to save the cache when an exception occurs
             try:
                 self._load_all_cache()
             except Exception as save_error:
-                PrettyOutput.print(f"Failed to save cache: {str(save_error)}", 
+                PrettyOutput.print(f"保存缓存失败: {str(save_error)}", 
                                 output_type=OutputType.ERROR)
             raise e  # Re-raise the original exception
 
@@ -524,7 +524,7 @@ Content: {content}
         score = len(matched_keywords) / len(keywords)
         return score
 
-    def pick_results(self, query: List[str], initial_results: List[str]) -> List[str]:
+    def pick_results(self, query: List[str], initial_results: List[str]) -> List[Dict[str,str]]:
         """Use a large model to pick the search results
         
         Args:
@@ -538,14 +538,14 @@ Content: {content}
             return []
             
         try:
-            PrettyOutput.print(f"Picking results for query: \n" + "\n".join(query), output_type=OutputType.INFO)
+            PrettyOutput.print(f"Picking results ...", output_type=OutputType.INFO)
             
             # Maximum content length per batch
             max_batch_length = self.max_token_count - 1000  # Reserve space for prompt
             max_file_length = max_batch_length // 3  # Limit individual file size
             
             # Process files in batches
-            all_selected_files = set()
+            all_selected_files = []
             current_batch = []
             current_token_count = 0
             
@@ -565,7 +565,7 @@ Content: {content}
                         # Process current batch
                         if current_batch:
                             selected = self._process_batch('\n'.join(query), current_batch)
-                            all_selected_files.update(selected)
+                            all_selected_files.extend(selected)
                         # Start new batch
                         current_batch = [file_info]
                         current_token_count = tokens_count
@@ -574,23 +574,22 @@ Content: {content}
                         current_token_count += tokens_count
                         
                 except Exception as e:
-                    PrettyOutput.print(f"Failed to read file {path}: {str(e)}", OutputType.ERROR)
+                    PrettyOutput.print(f"读取 {path} 失败: {str(e)}", OutputType.ERROR)
                     continue
             
             # Process final batch
             if current_batch:
                 selected = self._process_batch('\n'.join(query), current_batch)
-                all_selected_files.update(selected)
+                all_selected_files.extend(selected)
             
             # Convert set to list and maintain original order
-            final_results = [path for path in initial_results if path in all_selected_files]
-            return final_results
+            return all_selected_files
 
         except Exception as e:
-            PrettyOutput.print(f"Failed to pick: {str(e)}", OutputType.ERROR)
-            return initial_results
+            PrettyOutput.print(f"选择失败: {str(e)}", OutputType.ERROR)
+            return [{"file": f, "reason": "" } for f in initial_results]
             
-    def _process_batch(self, query: str, files_info: List[str]) -> List[str]:
+    def _process_batch(self, query: str, files_info: List[str]) -> List[Dict[str, str]]:
         """Process a batch of files"""
         prompt = f"""As a code analysis expert, please help identify the most relevant files for the given query using chain-of-thought reasoning.
 
@@ -611,8 +610,10 @@ Think through this step by step:
 
 Please output your selection in YAML format:
 <FILES>
-- path/to/most/relevant.py
+- file: path/to/most/relevant.py
+  reason: xxxxxxxxxx
 - path/to/next/relevant.py
+  reason: yyyyyyyyyy
 </FILES>
 
 Important:
@@ -638,7 +639,7 @@ Important:
             selected_files = yaml.safe_load(files_match.group(1))
             return selected_files if selected_files else []
         except Exception as e:
-            PrettyOutput.print(f"Failed to parse response: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"解析响应失败: {str(e)}", OutputType.ERROR)
             return []
 
     def _generate_query_variants(self, query: str) -> List[str]:
@@ -686,7 +687,7 @@ Please provide 10 search-optimized expressions in the specified format.
             try:
                 variants = yaml.safe_load(question_match.group(1))
             except Exception as e:
-                PrettyOutput.print(f"Failed to parse variants: {str(e)}", OutputType.ERROR)
+                PrettyOutput.print(f"解析变体失败: {str(e)}", OutputType.ERROR)
         
         # Add original query
         variants.append(query)
@@ -724,7 +725,7 @@ Please provide 10 search-optimized expressions in the specified format.
         return results
 
 
-    def search_similar(self, query: str, top_k: int = 30) -> List[str]:
+    def search_similar(self, query: str, top_k: int = 30) -> List[Dict[str, str]]:
         """Search related files with optimized retrieval"""
         try:
             self.generate_codebase()
@@ -764,32 +765,27 @@ Please provide 10 search-optimized expressions in the specified format.
             all_results.sort(key=lambda x: x[1], reverse=True)
             results = all_results[:top_k]
 
-            # Display results with scores
-            message = "Found related files:\n"
-            for path, score, _ in results:
-                message += f"File: {path} (Score: {score:.3f})\n"
-            PrettyOutput.print(message.rstrip(), output_type=OutputType.INFO, lang="markdown")
-
             results = self.pick_results(query_variants, [path for path, _, _ in results])
+
+            output = "Found related files:\n"
+            for file in results:
+                output += f'''- {file['file']} ({file['reason']})\n'''
+            PrettyOutput.print(output, output_type=OutputType.INFO, lang="markdown")
+
             
             return results
             
         except Exception as e:
-            PrettyOutput.print(f"Failed to search: {str(e)}", output_type=OutputType.ERROR)
+            PrettyOutput.print(f"搜索失败: {str(e)}", output_type=OutputType.ERROR)
             return []
 
-    def ask_codebase(self, query: str, top_k: int=20) -> str:
+    def ask_codebase(self, query: str, top_k: int=20) -> Tuple[List[Dict[str, str]], str]:
         """Query the codebase with enhanced context building"""
         files_from_codebase = self.search_similar(query, top_k)
         
         if not files_from_codebase:
-            PrettyOutput.print("No related files found", output_type=OutputType.WARNING)
-            return ""
-        
-        output = "Found related files:\n"
-        for path in files_from_codebase:
-            output += f"- {path}\n"
-        PrettyOutput.print(output, output_type=OutputType.INFO, lang="markdown")
+            PrettyOutput.print("没有找到相关文件", output_type=OutputType.WARNING)
+            return [],""
         
         # Build enhanced prompt
         prompt = f"""Based on the following code files, please provide a comprehensive and accurate answer to the user's question.
@@ -799,6 +795,8 @@ Important guidelines:
 2. Explain technical concepts clearly
 3. Include relevant code snippets when helpful
 4. If the code doesn't fully answer the question, indicate what's missing
+5. Answer in user's language.
+6. Answer with professional language.
 
 Question: {query}
 
@@ -810,16 +808,16 @@ Relevant code files (ordered by relevance):
         
         for path in files_from_codebase:
             try:
-                content = open(path, "r", encoding="utf-8").read()
+                content = open(path["file"], "r", encoding="utf-8").read()
                 file_content = f"""
-File: {path}
+File: {path["file"]}
 Content:
 {content}
 ----------------------------------------
 """
                 if current_count + get_context_token_count(file_content) > available_count:
                     PrettyOutput.print(
-                        "Due to context length limit, some files were omitted", 
+                        "由于上下文长度限制, 一些文件被省略", 
                         output_type=OutputType.WARNING
                     )
                     break
@@ -828,25 +826,21 @@ Content:
                 current_count += get_context_token_count(file_content)
                 
             except Exception as e:
-                PrettyOutput.print(f"Failed to read file {path}: {str(e)}", 
+                PrettyOutput.print(f"读取 {path} 失败: {str(e)}", 
                                 output_type=OutputType.ERROR)
                 continue
         
+        model = PlatformRegistry.get_global_platform_registry().get_thinking_platform()
+
         prompt += """
-Please structure your answer as follows:
-1. Direct answer to the question
-2. Relevant code explanations
-3. Implementation details
-4. Any missing information or limitations
-5. Add reference files and code snippets at the end of the answer.
-
-Answer in Chinese using professional language.
+Output Format:
+- question: the question to answer
+  answer: the answer to the question
+- question: the question to answer
+  answer: the answer to the question
 """
-        
-        model = PlatformRegistry.get_global_platform_registry().get_normal_platform()
-        response = model.chat_until_success(prompt)
-        
-        return response
+
+        return files_from_codebase, model.chat_until_success(prompt)
 
     def is_index_generated(self) -> bool:
         """Check if the index has been generated"""
@@ -886,7 +880,7 @@ Answer in Chinese using professional language.
             return True
             
         except Exception as e:
-            PrettyOutput.print(f"Error checking index status: {str(e)}", 
+            PrettyOutput.print(f"检查索引状态失败: {str(e)}", 
                              output_type=OutputType.ERROR)
             return False
 
@@ -931,24 +925,24 @@ def main():
     if args.command == 'generate':
         try:
             codebase.generate_codebase(force=args.force)
-            PrettyOutput.print("Codebase generation completed", output_type=OutputType.SUCCESS)
+            PrettyOutput.print("代码库生成完成", output_type=OutputType.SUCCESS)
         except Exception as e:
-            PrettyOutput.print(f"Error during codebase generation: {str(e)}", output_type=OutputType.ERROR)
+            PrettyOutput.print(f"代码库生成失败: {str(e)}", output_type=OutputType.ERROR)
     
     elif args.command == 'search':
         results = codebase.search_similar(args.query, args.top_k)
         if not results:
-            PrettyOutput.print("No similar files found", output_type=OutputType.WARNING)
+            PrettyOutput.print("没有找到相似的文件", output_type=OutputType.WARNING)
             return
             
-        output = "Search Results:\n"
+        output = "搜索结果:\n"
         for path in results:
             output += f"""- {path}\n"""
         PrettyOutput.print(output, output_type=OutputType.INFO, lang="markdown")
 
     elif args.command == 'ask':            
         response = codebase.ask_codebase(args.question, args.top_k)
-        output = f"""Answer:\n{response}"""
+        output = f"""{response}"""
         PrettyOutput.print(output, output_type=OutputType.INFO)
 
     else:

jarvis/jarvis_lsp/cpp.py

@@ -41,7 +41,7 @@ class CPPLSP(BaseLSP):
             
             return True
         except Exception as e:
-            PrettyOutput.print(f"C++ LSP initialization failed: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"C++ LSP 初始化失败: {str(e)}", OutputType.ERROR)
             return False
     
     def _send_request(self, method: str, params: Dict) -> Optional[Dict]:

jarvis/jarvis_lsp/go.py

@@ -47,7 +47,7 @@ class GoLSP(BaseLSP):
             
             return True
         except Exception as e:
-            PrettyOutput.print(f"Go LSP initialization failed: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Go LSP 初始化失败: {str(e)}", OutputType.ERROR)
             return False
     
     def _send_request(self, method: str, params: Dict) -> Optional[Dict]:

jarvis/jarvis_lsp/python.py

@@ -1,8 +1,6 @@
-import os
 from typing import List, Dict, Optional, Tuple, Any
 import jedi
 from jarvis.jarvis_lsp.base import BaseLSP
-from jarvis.utils import PrettyOutput, OutputType
 
 class PythonLSP(BaseLSP):
     """Python LSP implementation using jedi."""

jarvis/jarvis_lsp/registry.py

@@ -33,7 +33,7 @@ class LSPRegistry:
                 with open(os.path.join(user_lsp_dir, "__init__.py"), "w") as f:
                     pass
             except Exception as e:
-                PrettyOutput.print(f"Create LSP directory failed: {str(e)}", OutputType.ERROR)
+                PrettyOutput.print(f"创建 LSP 目录失败: {str(e)}", OutputType.ERROR)
                 return ""
         return user_lsp_dir
 
@@ -72,7 +72,7 @@ class LSPRegistry:
         lsp_servers = {}
         
         if not os.path.exists(directory):
-            PrettyOutput.print(f"LSP directory does not exist: {directory}", OutputType.ERROR)
+            PrettyOutput.print(f"LSP 目录不存在: {directory}", OutputType.ERROR)
             return lsp_servers
             
         package_name = None
@@ -104,7 +104,7 @@ class LSPRegistry:
                             lsp_servers[obj.language] = obj
                             break
                 except Exception as e:
-                    PrettyOutput.print(f"Load LSP {module_name} failed: {str(e)}", OutputType.ERROR)
+                    PrettyOutput.print(f"加载 LSP {module_name} 失败: {str(e)}", OutputType.ERROR)
         
         return lsp_servers
 
@@ -138,14 +138,14 @@ class LSPRegistry:
     def create_lsp(self, language: str) -> Optional[BaseLSP]:
         """Create LSP instance for specified language."""
         if language not in self.lsp_servers:
-            PrettyOutput.print(f"LSP not found for language: {language}", OutputType.ERROR)
+            PrettyOutput.print(f"没有找到 LSP 支持的语言: {language}", OutputType.ERROR)
             return None
             
         try:
             lsp = self.lsp_servers[language]()
             return lsp
         except Exception as e:
-            PrettyOutput.print(f"Create LSP failed: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"创建 LSP 失败: {str(e)}", OutputType.ERROR)
             return None
 
     def get_supported_languages(self) -> List[str]:
@@ -186,11 +186,11 @@ def main():
     lsp = registry.create_lsp(args.language)
     
     if not lsp:
-        PrettyOutput.print(f"No LSP support for language: {args.language}", OutputType.ERROR)
+        PrettyOutput.print(f"没有 LSP 支持的语言: {args.language}", OutputType.ERROR)
         return 1
         
     if not lsp.initialize(os.path.dirname(os.path.abspath(args.file))):
-        PrettyOutput.print("LSP initialization failed", OutputType.ERROR)
+        PrettyOutput.print("LSP 初始化失败", OutputType.ERROR)
         return 1
     
     try:
@@ -204,26 +204,26 @@ def main():
             diagnostics = lsp.get_diagnostics(args.file)
             for diag in diagnostics:
                 severity = ['Error', 'Warning', 'Info', 'Hint'][diag['severity'] - 1]
-                print(f"{severity} at {diag['range']['start']['line']}:{diag['range']['start']['character']}: {diag['message']}")
+                PrettyOutput.print(f"{severity} 在 {diag['range']['start']['line']}:{diag['range']['start']['character']}: {diag['message']}", OutputType.INFO)
                 
         elif args.action in ('references', 'definition'):
             if args.line is None or args.character is None:
-                PrettyOutput.print("Line and character position required for references/definition", OutputType.ERROR)
+                PrettyOutput.print("需要行和字符位置用于 references/definition", OutputType.ERROR)
                 return 1
                 
             if args.action == 'references':
                 refs = lsp.find_references(args.file, (args.line, args.character))
                 for ref in refs:
-                    print(f"Reference in {ref['uri']} at {ref['range']['start']['line']}:{ref['range']['start']['character']}\nLine: {LSPRegistry.get_line_at_position(ref['uri'], ref['range']['start']['line'])}")
+                    PrettyOutput.print(f"引用在 {ref['uri']} 在 {ref['range']['start']['line']}:{ref['range']['start']['character']}\n行: {LSPRegistry.get_line_at_position(ref['uri'], ref['range']['start']['line'])}", OutputType.INFO)
             else:
                 defn = lsp.find_definition(args.file, (args.line, args.character))
                 if defn:
-                    print(f"Definition in {defn['uri']} at {defn['range']['start']['line']}:{defn['range']['start']['character']}\nLine: {LSPRegistry.get_line_at_position(defn['uri'], defn['range']['start']['line'])}")
+                    PrettyOutput.print(f"定义在 {defn['uri']} 在 {defn['range']['start']['line']}:{defn['range']['start']['character']}\n行: {LSPRegistry.get_line_at_position(defn['uri'], defn['range']['start']['line'])}", OutputType.INFO)
                 else:
-                    print("No definition found")
+                    PrettyOutput.print("没有找到定义", OutputType.WARNING)
                     
     except Exception as e:
-        PrettyOutput.print(f"Error: {str(e)}", OutputType.ERROR)
+        PrettyOutput.print(f"错误: {str(e)}", OutputType.ERROR)
         return 1
     finally:
         lsp.shutdown()

jarvis/jarvis_lsp/rust.py

@@ -49,7 +49,7 @@ class RustLSP(BaseLSP):
             
             return True
         except Exception as e:
-            PrettyOutput.print(f"Rust LSP initialization failed: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Rust LSP 初始化失败: {str(e)}", OutputType.ERROR)
             return False
     
     def _send_request(self, method: str, params: Dict) -> Optional[Dict]: