jarvis-ai-assistant 0.1.101__py3-none-any.whl → 0.1.103__py3-none-any.whl

jarvis/{jarvis_coder → jarvis_code_agent}/file_select.py

@@ -1,4 +1,3 @@
-
 import os
 import re
 from typing import Dict, List
@@ -64,25 +63,23 @@ def _get_file_completer(root_dir: str) -> Completer:
             self.root_dir = root_dir
             
         def get_completions(self, document, complete_event):
-            # Get the text of the current input
             text = document.text_before_cursor
             
-            # If the input is empty, return all files in the root directory
             if not text:
                 for path in self._list_files(""):
                     yield Completion(path, start_position=0)
                 return
                 
-            # Get the current directory and partial file name
-            current_dir = os.path.dirname(text)
-            file_prefix = os.path.basename(text)
-            
-            # List matching files
-            search_dir = os.path.join(self.root_dir, current_dir) if current_dir else self.root_dir
-            if os.path.isdir(search_dir):
-                for path in self._list_files(current_dir):
-                    if path.startswith(text):
-                        yield Completion(path, start_position=-len(text))
+            # Generate fuzzy matching pattern
+            pattern = '.*'.join(map(re.escape, text))
+            try:
+                regex = re.compile(pattern, re.IGNORECASE)
+            except re.error:
+                return
+                
+            for path in self._list_files(""):
+                if regex.search(path):
+                    yield Completion(path, start_position=-len(text))
         
         def _list_files(self, current_dir: str) -> List[str]:
             """List all files in the specified directory (recursively)"""
@@ -93,7 +90,6 @@ def _get_file_completer(root_dir: str) -> Completer:
                 for filename in filenames:
                     full_path = os.path.join(root, filename)
                     rel_path = os.path.relpath(full_path, self.root_dir)
-                    # Ignore .git directory and other hidden files
                     if not any(part.startswith('.') for part in rel_path.split(os.sep)):
                         files.append(rel_path)
             
@@ -133,10 +129,13 @@ def select_files(related_files: List[str], root_dir: str) -> List[str]:
     """Let the user select and supplement related files"""
     PrettyOutput.section("Related files", OutputType.INFO)
     
+    output = ""
     # Display found files
     selected_files = list(related_files)  # Default select all
     for i, file in enumerate(related_files, 1):
-        PrettyOutput.print(f"[{i}] {file}", OutputType.INFO)
+        output += f"[{i}] {file}\n"
+
+    PrettyOutput.print(output, OutputType.INFO)
     
     # Ask the user if they need to adjust the file list
     user_input = get_single_line_input("Do you need to adjust the file list? (y/n) [n]").strip().lower() or 'n'
@@ -160,7 +159,7 @@ def select_files(related_files: List[str], root_dir: str) -> List[str]:
         )
         
         while True:
-            PrettyOutput.print("\nPlease enter the file path to supplement (support Tab completion and *? wildcard, input empty line to end):", OutputType.INFO)
+            PrettyOutput.print("Please enter the file path to supplement (support Tab completion and *? wildcard, input empty line to end):", OutputType.INFO)
             try:
                 file_path = session.prompt(">>> ").strip()
             except KeyboardInterrupt:
@@ -177,7 +176,7 @@ def select_files(related_files: List[str], root_dir: str) -> List[str]:
                     continue
                     
                 # Display matching files
-                PrettyOutput.print("\nFound the following matching files:", OutputType.INFO)
+                PrettyOutput.print("Found the following matching files:", OutputType.INFO)
                 for i, path in enumerate(matches, 1):
                     PrettyOutput.print(f"[{i}] {path}", OutputType.INFO)
                     

jarvis/jarvis_code_agent/patch.py

@@ -0,0 +1,118 @@
+import re
+from typing import Dict, Any, List, Tuple
+import os
+from jarvis.tools.git_commiter import GitCommitTool
+from jarvis.tools.read_code import ReadCodeTool
+from jarvis.utils import OutputType, PrettyOutput, has_uncommitted_changes, make_choice_input, user_confirm
+
+
+def _parse_patch(patch_str: str) -> Dict[str, List[Dict[str, Any]]]:
+    """Parse patches from string with format:
+    <PATCH>
+    > /path/to/file start_line,end_line
+    content_line1
+    content_line2
+    ...
+    </PATCH>
+    """
+    result = {}
+    patches = re.findall(r"<PATCH>(.*?)</PATCH>", patch_str, re.DOTALL)
+    
+    for patch in patches:
+        lines = patch.strip().split('\n')
+        if not lines:
+            continue
+            
+        # Parse file path and line range
+        file_info = lines[0].strip()
+        if not file_info.startswith('>'):
+            continue
+            
+        # Extract file path and line range
+        match = re.match(r'>\s*([^\s]+)\s+(\d+),(\d+)', file_info)
+        if not match:
+            continue
+            
+        filepath = match.group(1).strip()
+        start_line = int(match.group(2))
+        end_line = int(match.group(3))
+        
+        # Get content lines (skip the first line with file info)
+        content = '\n'.join(lines[1:])
+
+        if filepath not in result:
+            result[filepath] = []
+        
+        # Store in result dictionary
+        result[filepath].append({
+            'start_line': start_line,
+            'end_line': end_line,
+            'content': content
+        })
+    
+    # Sort patches by start line in reverse order to apply from bottom to top
+    for filepath in result:
+        result[filepath].sort(key=lambda x: x['start_line'], reverse=True)
+    
+    return result
+
+
+def apply_patch(output_str: str)->str:
+    """Apply patches to files"""
+    patches = _parse_patch(output_str)
+    if not patches:
+        return ""
+        
+    for filepath, patch_info in patches.items():
+        try:
+            # Check if file exists
+            if not os.path.exists(filepath):
+                PrettyOutput.print(f"File not found: {filepath}", OutputType.WARNING)
+                continue
+                
+            # Read original file content
+            lines = open(filepath, 'r', encoding='utf-8').readlines()
+            
+            # Apply patch
+            for patch in patch_info:
+                start_line = patch['start_line']
+                end_line = patch['end_line']
+                new_content = patch['content'].splitlines(keepends=True)
+
+                if new_content and new_content[-1] and new_content[-1][-1] != '\n':
+                    new_content[-1] += '\n'
+                # Validate line numbers
+                if start_line < 0 or end_line > len(lines) + 1 or start_line > end_line:
+                    PrettyOutput.print(f"Invalid line range [{start_line}, {end_line}) for file: {filepath}", OutputType.WARNING)
+                    continue
+                    
+                # Create new content
+                lines[start_line:end_line] = new_content
+                
+                # Write back to file
+                open(filepath, 'w', encoding='utf-8').writelines(lines)
+
+                PrettyOutput.print(f"Applied patch to {filepath} successfully\n", OutputType.SUCCESS)
+            
+        except Exception as e:
+            PrettyOutput.print(f"Error applying patch to {filepath}: {str(e)}", OutputType.ERROR)
+            continue
+    
+    if has_uncommitted_changes():
+        handle_commit_workflow()
+    return ""
+    
+def handle_commit_workflow()->bool:
+    """Handle the git commit workflow and return the commit details.
+    
+    Returns:
+        tuple[bool, str, str]: (continue_execution, commit_id, commit_message)
+    """
+    if not user_confirm("Do you want to commit the code?", default=True):
+        os.system("git reset HEAD")
+        os.system("git checkout -- .")
+        return False
+
+    git_commiter = GitCommitTool()
+    commit_result = git_commiter.execute({})
+    return commit_result["success"]

jarvis/jarvis_code_agent/relevant_files.py

@@ -0,0 +1,66 @@
+
+
+
+import os
+import re
+from typing import List
+
+import yaml
+from jarvis.agent import Agent
+from jarvis.jarvis_code_agent.file_select import select_files
+from jarvis.jarvis_codebase.main import CodeBase
+from jarvis.models.registry import PlatformRegistry
+from jarvis.tools.registry import ToolRegistry
+from jarvis.utils import OutputType, PrettyOutput, is_disable_codebase
+
+
+def find_relevant_files(user_input: str, root_dir: str) -> List[str]:
+    try:
+        files_from_codebase = []
+        if not is_disable_codebase():
+            PrettyOutput.print("Find files from codebase...", OutputType.INFO)
+            codebase = CodeBase(root_dir)
+            files_from_codebase = codebase.search_similar(user_input)
+
+        PrettyOutput.print("Find files by agent...", OutputType.INFO)
+        find_file_tool_registry = ToolRegistry()
+        find_file_tool_registry.use_tools(["read_code", "execute_shell"])
+        find_file_agent = Agent(
+            system_prompt="""You are a file agent, you are responsible for finding files related to the user's requirement.
+        You can use `read_code` tool to read the code and analyze the code, and `execute_shell` tool to execute shell command(such as `grep/find/ls/git/ctags`) to find files.
+
+        IMPORTANT:
+        - Only provide the file path, do not provide any other information.
+        - If you can't find the file, please provide empty list.
+        - Don't modify the code, just find related files.
+        """, 
+            name="FindFileAgent", 
+            is_sub_agent=True,
+            tool_registry=find_file_tool_registry, 
+            platform=PlatformRegistry().get_normal_platform(),
+            auto_complete=True,
+            summary_prompt="""Please provide the file path as this format(yaml list), if you can't find the file, please provide empty list:
+            <FILE_PATH>
+            - file_path1
+            - file_path2
+            </FILE_PATH>
+            """)
+        prompt = f"Find files related about '{user_input}'\n"
+        if files_from_codebase:
+            prompt += f"\n\nFiles maybe related: {files_from_codebase}\n\n Please read above files first"
+        output = find_file_agent.run(prompt)
+
+        rsp_from_agent = re.findall(r'<FILE_PATH>(.*?)</FILE_PATH>', output, re.DOTALL)
+        files_from_agent = []
+        if rsp_from_agent:
+            try:
+                files_from_agent = yaml.safe_load(rsp_from_agent[0])
+            except Exception as e:
+                files_from_agent = []
+        else:
+            files_from_agent = []
+
+        selected_files = select_files(files_from_agent, os.getcwd())
+        return selected_files
+    except Exception as e:
+        return []

jarvis/jarvis_codebase/main.py

@@ -59,7 +59,7 @@ class CodeBase:
         """Get the list of files in the git repository, excluding the .jarvis-codebase directory"""
         files = os.popen("git ls-files").read().splitlines()
         # Filter out files in the .jarvis-codebase directory
-        return [f for f in files if not f.startswith(".jarvis-")]
+        return [f for f in files if not f.startswith(".jarvis")]
 
     def is_text_file(self, file_path: str):
         with open(file_path, "r", encoding="utf-8") as f:
@@ -390,7 +390,7 @@ Content: {content}
             self.git_file_list = self.get_git_file_list()
             
             # Check file changes
-            PrettyOutput.print("\nCheck file changes...", output_type=OutputType.INFO)
+            PrettyOutput.print("Check file changes...", output_type=OutputType.INFO)
             changes_detected = False
             new_files = []
             modified_files = []
@@ -403,12 +403,13 @@ Content: {content}
                     deleted_files.append(file_path)
                     files_to_delete.append(file_path)
                     changes_detected = True
-            
             # Check new and modified files
-            with tqdm(total=len(self.git_file_list), desc="Check file status") as pbar:
+            from rich.progress import Progress
+            with Progress() as progress:
+                task = progress.add_task("Check file status", total=len(self.git_file_list))
                 for file_path in self.git_file_list:
                     if not os.path.exists(file_path) or not self.is_text_file(file_path):
-                        pbar.update(1)
+                        progress.advance(task)
                         continue
                     
                     try:
@@ -423,29 +424,28 @@ Content: {content}
                     except Exception as e:
                         PrettyOutput.print(f"Failed to check file {file_path}: {str(e)}", 
                                          output_type=OutputType.ERROR)
-                    pbar.update(1)
+                    progress.advance(task)
             
             # If changes are detected, display changes and ask the user
             if changes_detected:
-                PrettyOutput.print("\nDetected the following changes:", output_type=OutputType.WARNING)
+                output_lines = ["Detected the following changes:"]
                 if new_files:
-                    PrettyOutput.print("\nNew files:", output_type=OutputType.INFO)
-                    for f in new_files:
-                        PrettyOutput.print(f"  {f}", output_type=OutputType.INFO)
+                    output_lines.append("New files:")
+                    output_lines.extend(f"  {f}" for f in new_files)
                 if modified_files:
-                    PrettyOutput.print("\nModified files:", output_type=OutputType.INFO)
-                    for f in modified_files:
-                        PrettyOutput.print(f"  {f}", output_type=OutputType.INFO)
+                    output_lines.append("Modified files:")
+                    output_lines.extend(f"  {f}" for f in modified_files)
                 if deleted_files:
-                    PrettyOutput.print("\nDeleted files:", output_type=OutputType.INFO)
-                    for f in deleted_files:
-                        PrettyOutput.print(f"  {f}", output_type=OutputType.INFO)
+                    output_lines.append("Deleted files:")
+                    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:
                     # Ask the user whether to continue
                     while True:
-                        response = get_single_line_input("\nRebuild the index? [y/N]").lower().strip()
+                        response = get_single_line_input("Rebuild the index? [y/N]").lower().strip()
                         if response in ['y', 'yes']:
                             break
                         elif response in ['', 'n', 'no']:
@@ -487,7 +487,7 @@ Content: {content}
                             pbar.update(1)
 
                 if processed_files:
-                    PrettyOutput.print("\nRebuilding the vector database...", output_type=OutputType.INFO)
+                    PrettyOutput.print("Rebuilding the vector database...", output_type=OutputType.INFO)
                     self.gen_vector_db_from_cache()
                     PrettyOutput.print(f"Successfully generated the index for {len(processed_files)} files", 
                                     output_type=OutputType.SUCCESS)
@@ -693,6 +693,7 @@ Please output 3 expressions directly, separated by two line breaks, without numb
     def search_similar(self, query: str, top_k: int = 30) -> List[str]:
         """Search related files"""
         try:
+            self.generate_codebase()
             if self.index is None:
                 return []            
             # Generate the query variants
@@ -714,8 +715,10 @@ Please output 3 expressions directly, separated by two line breaks, without numb
             # Filter low-scoring results
             initial_results = [(path, score, desc) for path, score, desc in initial_results if score >= 0.5]
 
-            for path, score, desc in initial_results:
-                PrettyOutput.print(f"File: {path} Similarity: {score:.3f}", output_type=OutputType.INFO)
+            message = "Found related files:\n"
+            for path, score, _ in initial_results:
+                message += f"File: {path} Similarity: {score:.3f}\n"
+            PrettyOutput.print(message.rstrip(), output_type=OutputType.INFO)
                 
             # Reorder the preliminary results
             return self.pick_results(query, [path for path, _, _ in initial_results])
@@ -731,10 +734,10 @@ Please output 3 expressions directly, separated by two line breaks, without numb
             PrettyOutput.print("No related files found", output_type=OutputType.WARNING)
             return ""
         
-        PrettyOutput.print(f"Found related files: ", output_type=OutputType.SUCCESS)
+        message = "Found related files:\n"
         for path in results:
-            PrettyOutput.print(f"File: {path}", 
-                             output_type=OutputType.INFO)
+            message += f"File: {path}\n"
+        PrettyOutput.print(message.rstrip(), output_type=OutputType.SUCCESS)
         
         prompt = f"""You are a code expert, please answer the user's question based on the following file information:
 """
@@ -847,7 +850,7 @@ def main():
     if args.command == 'generate':
         try:
             codebase.generate_codebase(force=args.force)
-            PrettyOutput.print("\nCodebase generation completed", output_type=OutputType.SUCCESS)
+            PrettyOutput.print("Codebase generation completed", output_type=OutputType.SUCCESS)
         except Exception as e:
             PrettyOutput.print(f"Error during codebase generation: {str(e)}", output_type=OutputType.ERROR)
     
@@ -857,15 +860,15 @@ def main():
             PrettyOutput.print("No similar files found", output_type=OutputType.WARNING)
             return
             
-        PrettyOutput.print("\nSearch Results:", output_type=OutputType.INFO)
+        output = "Search Results:\n"
         for path in results:
-            PrettyOutput.print("\n" + "="*50, output_type=OutputType.INFO)
-            PrettyOutput.print(f"File: {path}", output_type=OutputType.INFO)
+            output += f"""{path}\n"""
+        PrettyOutput.print(output, output_type=OutputType.INFO)
 
     elif args.command == 'ask':            
         response = codebase.ask_codebase(args.question, args.top_k)
-        PrettyOutput.print("\nAnswer:", output_type=OutputType.INFO)
-        PrettyOutput.print(response, output_type=OutputType.INFO)
+        output = f"""Answer:\n{response}"""
+        PrettyOutput.print(output, output_type=OutputType.INFO)
 
     else:
         parser.print_help()

jarvis/jarvis_platform/main.py

@@ -21,13 +21,15 @@ def list_platforms():
             # Print platform name
             PrettyOutput.section(f"{platform_name}", OutputType.SUCCESS)
             
+            output = ""
             # Print model list
             if models:
                 for model_name, description in models:
                     if description:
-                        PrettyOutput.print(f"  • {model_name} - {description}", OutputType.SUCCESS)
+                        output += f"  • {model_name} - {description}\n"
                     else:
-                        PrettyOutput.print(f"  • {model_name}", OutputType.SUCCESS)
+                        output += f"  • {model_name}\n"
+                PrettyOutput.print(output, OutputType.SUCCESS)
             else:
                 PrettyOutput.print("  • No available model information", OutputType.WARNING)
                 
@@ -55,7 +57,7 @@ def chat_with_model(platform_name: str, model_name: str):
             user_input = get_multiline_input("")
             
             # Check if input is cancelled
-            if user_input == "__interrupt__" or user_input.strip() == "/bye":
+            if user_input.strip() == "/bye":
                 PrettyOutput.print("Bye!", OutputType.SUCCESS)
                 break
                 

jarvis/jarvis_rag/main.py

@@ -116,7 +116,7 @@ class PDFProcessor(FileProcessor):
         text_parts = []
         with fitz.open(file_path) as doc: # type: ignore
             for page in doc:
-                text_parts.append(page.get_text())
+                text_parts.append(page.get_text()) # type: ignore
         return "\n".join(text_parts)
 
 class DocxProcessor(FileProcessor):
@@ -696,12 +696,10 @@ Content: {doc.content}
             
             # Display found document fragments
             for doc in results:
-                PrettyOutput.print(f"File: {doc.metadata['file_path']}", output_type=OutputType.INFO)
-                PrettyOutput.print(f"Fragment {doc.metadata['chunk_index'] + 1}/{doc.metadata['total_chunks']}", 
-                                output_type=OutputType.INFO)
-                PrettyOutput.print("\nContent:", output_type=OutputType.INFO)
-                content = doc.content.encode('utf-8', errors='replace').decode('utf-8')
-                PrettyOutput.print(content, output_type=OutputType.INFO)
+                output = f"""File: {doc.metadata['file_path']}\n"""
+                output += f"""Fragment {doc.metadata['chunk_index'] + 1}/{doc.metadata['total_chunks']}\n"""
+                output += f"""Content:\n{doc.content}\n"""
+                PrettyOutput.print(output, output_type=OutputType.INFO)
 
             # Build base prompt
             base_prompt = f"""Please answer the user's question based on the following document fragments. If the document content is not sufficient to answer the question completely, please clearly indicate.
@@ -791,12 +789,10 @@ def main():
                     return 1
                     
                 for doc in results:
-                    PrettyOutput.print(f"\nFile: {doc.metadata['file_path']}", output_type=OutputType.INFO)
-                    PrettyOutput.print(f"Fragment {doc.metadata['chunk_index'] + 1}/{doc.metadata['total_chunks']}", 
-                                    output_type=OutputType.INFO)
-                    PrettyOutput.print("\nContent:", output_type=OutputType.INFO)
-                    content = doc.content.encode('utf-8', errors='replace').decode('utf-8')
-                    PrettyOutput.print(content, output_type=OutputType.INFO)
+                    output = f"""File: {doc.metadata['file_path']}\n"""
+                    output += f"""Fragment {doc.metadata['chunk_index'] + 1}/{doc.metadata['total_chunks']}\n"""
+                    output += f"""Content:\n{doc.content}\n"""
+                    PrettyOutput.print(output, output_type=OutputType.INFO)
                 return 0
 
             if args.ask:
@@ -807,8 +803,8 @@ def main():
                     return 1
                     
                 # Display answer
-                PrettyOutput.print("\nAnswer:", output_type=OutputType.INFO)
-                PrettyOutput.print(response, output_type=OutputType.INFO)
+                output = f"""Answer:\n{response}"""
+                PrettyOutput.print(output, output_type=OutputType.INFO)
                 return 0
 
         PrettyOutput.print("Please specify operation parameters. Use -h to view help.", output_type=OutputType.WARNING)

jarvis/jarvis_smart_shell/main.py

@@ -13,7 +13,7 @@ from jarvis.utils import PrettyOutput, OutputType, init_env
 def execute_command(command: str) -> None:
     """Show command and allow user to edit, then execute, Ctrl+C to cancel"""
     try:
-        print("\nGenerated command (can be edited, press Enter to execute, Ctrl+C to cancel):")
+        print("Generated command (can be edited, press Enter to execute, Ctrl+C to cancel):")
         # Pre-fill input line
         readline.set_startup_hook(lambda: readline.insert_text(command))
         try:
@@ -21,7 +21,7 @@ def execute_command(command: str) -> None:
             if edited_command.strip():  # Ensure command is not empty
                 os.system(edited_command)
         except KeyboardInterrupt:
-            print("\nExecution cancelled")
+            print("Execution cancelled")
         finally:
             readline.set_startup_hook()  # Clear pre-filled
     except Exception as e:

jarvis/models/ai8.py

@@ -14,6 +14,7 @@ class AI8Model(BasePlatform):
 
     def get_model_list(self) -> List[Tuple[str, str]]:
         """获取模型列表"""
+        self.get_available_models()
         return [(name,info['desc']) for name,info in self.models.items()]
     
     def __init__(self):

jarvis/models/kimi.py

@@ -25,21 +25,24 @@ class KimiModel(BasePlatform):
         self.chat_id = ""
         self.api_key = os.getenv("KIMI_API_KEY")
         if not self.api_key:
-            PrettyOutput.print("\nNeed to set KIMI_API_KEY to use Jarvis. Please follow the steps below:", OutputType.INFO)
-            PrettyOutput.print("\n1. Get Kimi API Key:", OutputType.INFO)
-            PrettyOutput.print("   • Visit Kimi AI platform: https://kimi.moonshot.cn", OutputType.INFO)
-            PrettyOutput.print("   • Login to your account", OutputType.INFO)
-            PrettyOutput.print("   • Open browser developer tools (F12 or right-click -> Inspect)", OutputType.INFO)
-            PrettyOutput.print("   • Switch to the Network tab", OutputType.INFO)
-            PrettyOutput.print("   • Send any message", OutputType.INFO)
-            PrettyOutput.print("   • Find the Authorization header in the request", OutputType.INFO)
-            PrettyOutput.print("   • Copy the token value (remove the 'Bearer ' prefix)", OutputType.INFO)
-            PrettyOutput.print("\n2. Set environment variable:", OutputType.INFO)
-            PrettyOutput.print("   • Method 1: Create or edit ~/.jarvis/env file:", OutputType.INFO)
-            PrettyOutput.print("   echo 'KIMI_API_KEY=your_key_here' > ~/.jarvis/env", OutputType.INFO)
-            PrettyOutput.print("\n   • Method 2: Set environment variable directly:", OutputType.INFO)
-            PrettyOutput.print("   export KIMI_API_KEY=your_key_here", OutputType.INFO)
-            PrettyOutput.print("\nAfter setting, run Jarvis again.", OutputType.INFO)
+            message = (
+                "Need to set KIMI_API_KEY to use Jarvis. Please follow the steps below:\n"
+                "1. Get Kimi API Key:\n"
+                "   • Visit Kimi AI platform: https://kimi.moonshot.cn\n"
+                "   • Login to your account\n" 
+                "   • Open browser developer tools (F12 or right-click -> Inspect)\n"
+                "   • Switch to the Network tab\n"
+                "   • Send any message\n"
+                "   • Find the Authorization header in the request\n"
+                "   • Copy the token value (remove the 'Bearer ' prefix)\n"
+                "2. Set environment variable:\n"
+                "   • Method 1: Create or edit ~/.jarvis/env file:\n"
+                "   echo 'KIMI_API_KEY=your_key_here' > ~/.jarvis/env\n"
+                "   • Method 2: Set environment variable directly:\n"
+                "   export KIMI_API_KEY=your_key_here\n"
+                "After setting, run Jarvis again."
+            )
+            PrettyOutput.print(message, OutputType.INFO)
             PrettyOutput.print("KIMI_API_KEY is not set", OutputType.WARNING)
         self.auth_header = f"Bearer {self.api_key}"
         self.chat_id = ""
@@ -308,42 +311,45 @@ class KimiModel(BasePlatform):
 
             # 显示搜索结果摘要
             if search_results and not self.suppress_output:
-                PrettyOutput.print("\n搜索结果:", OutputType.PROGRESS)
+                output = ["搜索结果:"]
                 for result in search_results:
-                    PrettyOutput.print(f"- {result['title']}", OutputType.PROGRESS)
+                    output.append(f"- {result['title']}")
                     if result['date']:
-                        PrettyOutput.print(f"  日期: {result['date']}", OutputType.PROGRESS)
-                    PrettyOutput.print(f"  来源: {result['site_name']}", OutputType.PROGRESS)
+                        output.append(f"  日期: {result['date']}")
+                    output.append(f"  来源: {result['site_name']}")
                     if result['snippet']:
-                        PrettyOutput.print(f"  摘要: {result['snippet']}", OutputType.PROGRESS)
-                    PrettyOutput.print(f"  链接: {result['url']}", OutputType.PROGRESS)
-                    PrettyOutput.print("", OutputType.PROGRESS)
+                        output.append(f"  摘要: {result['snippet']}")
+                    output.append(f"  链接: {result['url']}")
+                    output.append("")
+                PrettyOutput.print("\n".join(output), OutputType.PROGRESS)
                         
             # 显示引用来源
             if ref_sources and not self.suppress_output:
-                PrettyOutput.print("\n引用来源:", OutputType.PROGRESS)
+                output = ["引用来源:"]
                 for source in ref_sources:
-                    PrettyOutput.print(f"- [{source['ref_id']}] {source['title']} ({source['source']})", OutputType.PROGRESS)
-                    PrettyOutput.print(f"  链接: {source['url']}", OutputType.PROGRESS)
+                    output.append(f"- [{source['ref_id']}] {source['title']} ({source['source']})")
+                    output.append(f"  链接: {source['url']}")
                     if source['abstract']:
-                        PrettyOutput.print(f"  摘要: {source['abstract']}", OutputType.PROGRESS)
+                        output.append(f"  摘要: {source['abstract']}")
                     
                     # 显示相关段落
                     if source['rag_segments']:
-                        PrettyOutput.print("  相关段落:", OutputType.PROGRESS)
+                        output.append("  相关段落:")
                         for segment in source['rag_segments']:
                             text = segment.get('text', '').replace('\n', ' ').strip()
                             if text:
-                                PrettyOutput.print(f"    - {text}", OutputType.PROGRESS)
+                                output.append(f"    - {text}")
                     
                     # 显示原文引用
                     origin = source['origin']
                     if origin:
                         text = origin.get('text', '')
                         if text:
-                            PrettyOutput.print(f"  原文: {text}", OutputType.PROGRESS)
+                            output.append(f"  原文: {text}")
                     
-                    PrettyOutput.print("", OutputType.PROGRESS)
+                    output.append("")
+
+                PrettyOutput.print("\n".join(output), OutputType.PROGRESS)
 
             PrettyOutput.print(full_response, OutputType.RESULT)