jarvis-ai-assistant 0.1.132__py3-none-any.whl → 0.1.138__py3-none-any.whl

jarvis/jarvis_code_agent/code_agent.py

@@ -1,5 +1,13 @@
-import subprocess
+"""Jarvis代码代理模块。
+
+该模块提供CodeAgent类，用于处理代码修改任务。
+"""
+
 import os
+import sys
+import subprocess
+import argparse
+from typing import Optional
 
 from yaspin import yaspin
 
@@ -10,145 +18,197 @@ from jarvis.jarvis_agent.shell_input_handler import shell_input_handler
 from jarvis.jarvis_agent.patch import PatchOutputHandler
 from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_tools.git_commiter import GitCommitTool
-
 from jarvis.jarvis_tools.registry import ToolRegistry
-from jarvis.jarvis_utils.git_utils import find_git_root, get_commits_between, get_latest_commit_hash, has_uncommitted_changes
+from jarvis.jarvis_utils.git_utils import (
+    find_git_root,
+    get_commits_between,
+    get_latest_commit_hash,
+    has_uncommitted_changes
+)
 from jarvis.jarvis_utils.input import get_multiline_input
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.utils import init_env, user_confirm
 
 
+class CodeAgent:
+    """Jarvis系统的代码修改代理。
 
+    负责处理代码分析、修改和git操作。
+    """
 
-
-class CodeAgent:
-    def __init__(self):
+    def __init__(self, platform: Optional[str] = None,
+                model: Optional[str] = None,
+                need_summary: bool = True):
         self.root_dir = os.getcwd()
         tool_registry = ToolRegistry()
-        tool_registry.use_tools(["execute_shell", 
-                                 "execute_shell_script",
-                                 "search_web", 
-                                 "ask_user",  
-                                 "ask_codebase",
-                                 "lsp_get_diagnostics", 
-                                 "lsp_find_references", 
-                                 "lsp_find_definition",
-                                 "code_review",  # 代码审查工具
-                                 "find_symbol",  # 添加符号查找工具
-                                 "find_caller",  # 添加函数调用者查找工具
-                                 "function_analyzer",  # 添加函数分析工具
-                                 "project_analyzer",  # 添加项目分析工具
-                                 "file_analyzer"  # 添加单文件分析工具
-                                 ])
+        tool_registry.use_tools([
+            "execute_shell",
+            "execute_shell_script",
+            "search_web",
+            "ask_user",
+            "ask_codebase",
+            "lsp_get_diagnostics",
+            "code_review",
+            "find_symbol",
+            "find_caller",
+            "function_analyzer",
+            "project_analyzer",
+            "file_analyzer",
+            "read_code"
+        ])
         code_system_prompt = """
-# 专业代码工程师
-
-## 身份与职责
-- **角色**：精通代码修改的高级工程师
-- **能力**：代码分析、精准重构和系统化验证
-- **知识**：软件架构、设计模式和编程最佳实践
-
-## 工作原则
-- **准备工作**：在修改任何代码之前，必须已经阅读并充分理解相关代码
-- **分析范围判断**：首先评估当前文件内容是否足够完成修改，避免不必要的项目分析
-- **沟通**：清晰简洁的技术解释，提供决策依据
-- **代码修改**：结构化展示变更及其上下文
-- **问题处理**：遇到模糊请求时提出澄清问题，高风险变更时提出渐进式方法
-- **修改效率**：对于变更不超过50行的代码，应一次性完成修改，避免分段处理
-
-## 任务执行流程
-### 分析阶段
-- **范围确定**：首先判断是否仅需当前文件内容即可完成任务，避免不必要的分析
-- 评估任务复杂度，只在必要时进行全面分析
-- 简单修改可直接进行，无需复杂分析
-- 使用代码分析工具理解依赖关系
-- 识别潜在影响区域
-- 确保在开始修改前，已经完全阅读和理解相关代码文件
-
-### 实施阶段
-- 进行最小范围更改，保持代码完整性
-- 对于不超过50行的代码变更，应一次性完成修改
-- 大型文件分段修改，确保每段修改后代码功能完整
-- 保持一致的代码风格和格式
-- 修改后立即验证，优先修复错误
-
-### 验证阶段
-- 确认已充分理解所修改代码及其上下文
-- 使用诊断工具检查问题
-- 检查相关代码中的意外副作用
-- 确保兼容性和功能正确性
-- 验证修改是否符合原始设计意图和代码结构
-
-### 文档阶段
-- 提供清晰的修改理由和上下文
-- 记录假设和约束条件
-- 准备详细的提交信息
-
-## 工具使用指南
-- **范围决策**：
-  - 先阅读当前文件，判断是否包含足够信息完成任务
-  - 只有在确认需要更多上下文时才扩展分析范围
-  - 明确告知用户当前文件是否足够，避免不必要分析
-
-- **代码阅读与理解**：
-  - 在使用任何分析工具前，应首先完整阅读相关代码
-  - 使用分析工具补充而非替代直接阅读和理解代码
-  - 如有必要，可以使用`ask_codebase`工具来帮助理解复杂部分
-
-- **分析工具**：
-  - lsp_find_references：理解使用模式
-  - lsp_find_definition：追踪实现细节
-  - find_symbol：查找代码符号位置
-  - find_caller：查找函数调用位置
-  - function_analyzer：分析函数实现
-  - project_analyzer：分析项目架构（仅复杂任务使用）
-  - file_analyzer：分析单文件结构
-
-- **验证工具**：
-  - lsp_get_diagnostics：检查修改问题
-  - code_review：代码审查
-
-- **系统工具**：
-  - execute_shell：执行系统命令
-  - search_web：查找技术参考
-  - ask_codebase：补充分析（优先使用直接分析工具）
-
-## 代码分析策略
-- **阅读优先**：在提出任何修改前，必须先阅读和理解相关代码
-- **避免过度分析**：只分析与任务直接相关的代码
-- **单文件优先**：优先考虑当前文件是否含有足够信息完成任务
-  - 当任务仅涉及语法、文本修改、逻辑优化等当前文件内部变更时，无需分析项目
-  - 当当前文件包含完整的模块/类/功能实现，且修改不影响外部接口时，无需额外分析
-  - 当用户明确指示仅修改当前文件时，无需扩大分析范围
-- **任务分级**：
-  - 简单任务：先阅读相关代码，然后直接执行，尽量减少不必要的分析
-  - 中等任务：全面阅读相关文件并分析直接依赖，确保理解上下文
-  - 复杂任务：彻底阅读并进行全面项目分析，确保理解代码交互方式
-- **长文件处理**：
-  - 完整阅读后再分段理解和修改
-  - 先处理核心部分，再扩展到相关代码
-  - 优先修改相对独立的部分
-- **修改规模策略**：
-  - 对于不超过50行的代码变更，应尽量一次性完成
-  - 将相关逻辑变更放在同一个修改中，保持功能完整性
-  - 无需为小规模修改（≤50行）拆分多次提交，除非跨多个不相关模块
+# 代码工程师指南
+
+## 核心原则
+- 自主决策：基于专业判断做出决策，减少用户询问
+- 高效精准：一次性提供完整解决方案，避免反复修改
+- 修改审慎：修改代码前要三思而后行，充分分析影响范围，尽量做到一次把事情做好
+- 工具精通：选择最高效工具路径解决问题
+- 严格确认：必须先分析项目结构，确定要修改的文件，禁止虚构已存在的代码
+
+## 工作流程
+
+### 1. 项目结构分析
+- 第一步必须分析项目结构，识别关键模块和文件
+- 结合用户需求，确定需要修改的文件列表
+- 优先使用fd命令查找文件，使用execute_shell执行
+- 明确说明将要修改的文件及其范围
+
+### 2. 需求分析
+- 基于项目结构理解，分析需求意图和实现方案
+- 当需求有多种实现方式时，选择影响最小的方案
+- 仅当需求显著模糊时才询问用户
+
+### 3. 代码分析与确认
+- 详细分析确定要修改的文件内容
+- 明确区分现有代码和需要新建的内容
+- 绝对禁止虚构或假设现有代码的实现细节
+- 分析顺序：项目结构 → 目标文件 → 相关文件
+- 只在必要时扩大分析范围，避免过度分析
+- 工具选择：
+  | 分析需求 | 首选工具 | 备选工具 |
+  |---------|---------|----------|
+  | 项目结构 | fd (通过execute_shell) | project_analyzer(仅在必要时) |
+  | 文件内容 | read_code | file_analyzer(仅在必要时) |
+  | 查找引用 | rg (通过execute_shell) | find_symbol(仅在必要时) |
+  | 查找定义 | rg (通过execute_shell) | find_symbol(仅在必要时) |
+  | 函数调用者 | rg (通过execute_shell) | find_caller(仅在必要时) |
+  | 函数分析 | read_code + rg | function_analyzer(仅在必要时) |
+  | 整体分析 | execute_shell_script | ask_codebase(仅在必要时) |
+  | 代码质量检查 | execute_shell | code_review(仅在必要时) |
+  | 统计代码行数 | loc (通过execute_shell) | - |
+
+### 4. 方案设计
+- 确定最小变更方案，保持代码结构
+- 变更类型处理：
+  - 修改现有文件：必须先确认文件存在及其内容
+  - 创建新文件：可以根据需求创建，但要符合项目结构和风格
+- 变更规模处理：
+  - ≤50行：一次性完成所有修改
+  - 50-200行：按功能模块分组
+  - >200行：按功能拆分，但尽量减少提交次数
+
+### 5. 实施修改
+- 遵循"先读后写"原则，在修改已有代码前，必须已经读取了对应文件
+- 保持代码风格一致性
+- 自动匹配项目现有命名风格
+- 允许创建新文件和结构，但不得假设或虚构现有代码
+
+## 专用工具简介
+仅在必要时使用以下专用工具：
+
+- **project_analyzer**: 项目整体结构分析，仅在fd命令无法满足需求时使用
+- **file_analyzer**: 单文件深度分析，应优先使用read_code替代
+- **find_caller**: 函数调用者查找，应优先使用rg命令替代
+- **find_symbol**: 符号引用查找，应优先使用rg命令替代
+- **function_analyzer**: 函数实现分析，应优先使用read_code和rg组合替代
+- **ask_codebase**: 代码库整体查询，应优先使用fd、rg和read_code组合替代
+- **code_review**: 代码质量检查，应优先使用语言特定的lint工具替代
+
+## Shell命令优先策略
+
+### 优先使用的Shell命令
+- **项目结构分析**：
+  - `fd -t f -e py` 查找所有Python文件
+  - `fd -t f -e js -e ts` 查找所有JavaScript/TypeScript文件
+  - `fd -t d` 列出所有目录
+  - `fd -t f -e java -e kt` 查找所有Java/Kotlin文件
+  - `fd -t f -e go` 查找所有Go文件
+  - `fd -t f -e rs` 查找所有Rust文件
+  - `fd -t f -e c -e cpp -e h -e hpp` 查找所有C/C++文件
+
+- **代码内容搜索**：
+  - `rg "pattern" --type py` 在Python文件中搜索
+  - `rg "pattern" --type js` 在JavaScript文件中搜索
+  - `rg "pattern" --type java` 在Java文件中搜索
+  - `rg "pattern" --type c` 在C文件中搜索
+  - `rg "class ClassName"` 查找类定义
+  - `rg "func|function|def" -g "*.py" -g "*.js" -g "*.go" -g "*.rs"` 查找函数定义
+  - `rg -w "word"` 精确匹配单词
+
+- **代码统计分析**：
+  - `loc` 统计当前目录代码行数
+
+- **代码质量检查**：
+  - Python: `pylint <file_path>`, `flake8 <file_path>`
+  - JavaScript: `eslint <file_path>`
+  - TypeScript: `tsc --noEmit <file_path>`
+  - Java: `checkstyle <file_path>`
+  - Go: `go vet <file_path>`
+  - Rust: `cargo clippy`
+  - C/C++: `cppcheck <file_path>`
+
+- **整体代码分析**：
+  - 使用execute_shell_script编写和执行脚本，批量分析多个文件
+  - 简单脚本示例：`find . -name "*.py" | xargs pylint`
+  - 使用多工具组合：`fd -e py | xargs pylint`
+
+### read_code工具使用
+读取文件应优先使用read_code工具，而非shell命令：
+- 完整读取：使用read_code读取整个文件内容
+- 部分读取：使用read_code指定行范围
+- 大文件处理：对大型文件使用read_code指定行范围，避免全部加载
+
+### 仅在命令行工具不足时使用专用工具
+只有当fd、rg、loc和read_code工具无法获取足够信息时，才考虑使用专用工具（ask_codebase、code_review等）。在每次使用专用工具前，应先尝试使用上述工具获取所需信息。
+
+### 注意事项
+- read_code比cat或grep更适合阅读代码
+- rg比grep更快更强大，应优先使用
+- fd比find更快更易用，应优先使用
+- loc比wc -l提供更多代码统计信息，应优先使用
+- 针对不同编程语言选择对应的代码质量检查工具
+- 不要留下未实现的代码
 """
         # Dynamically add ask_codebase based on task complexity if really needed
-        self.agent = Agent(system_prompt=code_system_prompt, 
-                           name="CodeAgent", 
+        # 处理platform参数
+        platform_instance = (PlatformRegistry().create_platform(platform)
+                             if platform
+                             else PlatformRegistry().get_normal_platform())
+        if model:
+            platform_instance.set_model_name(model)  # type: ignore
+
+        self.agent = Agent(system_prompt=code_system_prompt,
+                           name="CodeAgent",
                            auto_complete=False,
-                           is_sub_agent=False, 
-                           use_methodology=False,
-                           output_handler=[tool_registry, PatchOutputHandler()], 
-                           platform=PlatformRegistry().get_codegen_platform(), 
-                           record_methodology=False,
-                           input_handler=[shell_input_handler, file_input_handler, builtin_input_handler],
-                           need_summary=False)
-
-    
+                           output_handler=[tool_registry,
+                                           PatchOutputHandler()],
+                           platform=platform_instance,
+                           input_handler=[
+                               shell_input_handler, file_input_handler, builtin_input_handler],
+                           need_summary=need_summary)
+        self.agent.set_addon_prompt("请使用工具充分理解用户需求，然后根据需求一步步执行代码修改/开发")
+
+    def get_root_dir(self) -> str:
+        """获取项目根目录
+
+        返回:
+            str: 项目根目录路径
+        """
+        return self.root_dir
 
     def _init_env(self):
-        with yaspin(text="正在初始化环境...", color="cyan") as spinner: 
+        with yaspin(text="正在初始化环境...", color="cyan") as spinner:
             curr_dir = os.getcwd()
             git_dir = find_git_root(curr_dir)
             self.root_dir = git_dir
@@ -159,79 +219,105 @@ class CodeAgent:
             spinner.text = "环境初始化完成"
             spinner.ok("✅")
 
-    
-
-    def run(self, user_input: str) :
-        """Run the code agent with the given user input.
-        
-        Args:
-            user_input: The user's requirement/request
-            
-        Returns:
-            str: Output describing the execution result
+    def _handle_uncommitted_changes(self):
+        """处理未提交的修改"""
+        if has_uncommitted_changes():
+            PrettyOutput.print("检测到未提交的修改，是否要提交？", OutputType.WARNING)
+            if user_confirm("是否要提交？", True):
+                git_commiter = GitCommitTool()
+                git_commiter.execute({})
+
+    def _show_commit_history(self, start_commit, end_commit):
+        """显示提交历史"""
+        if start_commit and end_commit:
+            commits = get_commits_between(start_commit, end_commit)
+        else:
+            commits = []
+
+        if commits:
+            commit_messages = "检测到以下提交记录:\n" + \
+                "\n".join(
+                    [f"- {commit_hash[:7]}: {message}" for commit_hash, message in commits])
+            PrettyOutput.print(commit_messages, OutputType.INFO)
+        return commits
+
+    def _handle_commit_confirmation(self, commits, start_commit):
+        """处理提交确认和可能的重置"""
+        if commits and user_confirm("是否接受以上提交记录？", True):
+            if len(commits) > 1 and user_confirm(
+                "是否要合并为一个更清晰的提交记录？", True
+            ):
+                # Reset to start commit
+                subprocess.run(
+                    ["git", "reset", "--mixed", start_commit],
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                    check=True
+                )
+                # Create new commit
+                git_commiter = GitCommitTool()
+                git_commiter.execute({})
+        elif start_commit:
+            os.system(f"git reset --hard {start_commit}")
+            PrettyOutput.print("已重置到初始提交", OutputType.INFO)
+
+    def run(self, user_input: str) -> Optional[str]:
+        """使用给定的用户输入运行代码代理。
+
+        参数:
+            user_input: 用户的需求/请求
+
+        返回:
+            str: 描述执行结果的输出，成功时返回None
         """
         try:
             self._init_env()
-            
             start_commit = get_latest_commit_hash()
-            
+
             try:
                 self.agent.run(user_input)
-            except Exception as e:
+            except RuntimeError as e:
                 PrettyOutput.print(f"执行失败: {str(e)}", OutputType.WARNING)
-            
+                return str(e)
+
+            self._handle_uncommitted_changes()
             end_commit = get_latest_commit_hash()
-            # Print commit history between start and end commits
-            if start_commit and end_commit:
-                commits = get_commits_between(start_commit, end_commit)
-            else:
-                commits = []
-            
-            if commits:
-                commit_messages = "检测到以下提交记录:\n" + "\n".join([f"- {commit_hash[:7]}: {message}" for commit_hash, message in commits])
-                PrettyOutput.print(commit_messages, OutputType.INFO)
-
-            if commits and user_confirm("是否接受以上提交记录？", True):
-                if len(commits) > 1 and user_confirm("是否要合并为一个更清晰的提交记录？", True):
-                    # Reset to start commit
-                    subprocess.run(["git", "reset", "--mixed", start_commit], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-                    # Create new commit
-                    git_commiter = GitCommitTool()
-                    git_commiter.execute({})
-            elif start_commit:
-                os.system(f"git reset --hard {start_commit}")
-                PrettyOutput.print("已重置到初始提交", OutputType.INFO)
-                
-        except Exception as e:
+            commits = self._show_commit_history(start_commit, end_commit)
+            self._handle_commit_confirmation(commits, start_commit)
+            return None
+
+        except RuntimeError as e:
             return f"Error during execution: {str(e)}"
-        
 
 
 def main():
-    """Jarvis main entry point"""
-    # Add argument parser
+    """Jarvis主入口点。"""
     init_env()
 
+    parser = argparse.ArgumentParser(description='Jarvis Code Agent')
+    parser.add_argument('-p', '--platform', type=str,
+                      help='Target platform name', default=None)
+    parser.add_argument('-m', '--model', type=str,
+                      help='Model name to use', default=None)
+    args = parser.parse_args()
+
     curr_dir = os.getcwd()
     git_dir = find_git_root(curr_dir)
     PrettyOutput.print(f"当前目录: {git_dir}", OutputType.INFO)
 
     try:
-        try:
-            user_input = get_multiline_input("请输入你的需求（输入空行退出）:")
-            if not user_input:
-                return 0
-            agent = CodeAgent()
-            agent.run(user_input)
-            
-        except Exception as e:
-            PrettyOutput.print(f"错误: {str(e)}", OutputType.ERROR)
+        user_input = get_multiline_input("请输入你的需求（输入空行退出）:")
+        if not user_input:
+            sys.exit(0)
+        agent = CodeAgent(platform=args.platform,
+                        model=args.model,
+                        need_summary=False)
+        agent.run(user_input)
 
-    except Exception as e:
-        PrettyOutput.print(f"初始化错误: {str(e)}", OutputType.ERROR)
-        return 1
+    except RuntimeError as e:
+        PrettyOutput.print(f"错误: {str(e)}", OutputType.ERROR)
+        sys.exit(1)
 
-    return 0
 
 if __name__ == "__main__":
-    exit(main())
+    main()

jarvis/jarvis_code_agent/file_select.py

@@ -11,15 +11,15 @@ from jarvis.jarvis_utils.utils import user_confirm
 
 def _parse_file_selection(input_str: str, max_index: int) -> List[int]:
     selected = set()
-    
+
     # Remove all whitespace characters
     input_str = "".join(input_str.split())
-    
+
     # Process comma-separated parts
     for part in input_str.split(","):
         if not part:
             continue
-        
+
         # Process range (e.g.: 3-6)
         if "-" in part:
             try:
@@ -41,7 +41,7 @@ def _parse_file_selection(input_str: str, max_index: int) -> List[int]:
                     PrettyOutput.print(f"忽略超出范围的索引: {part}", OutputType.WARNING)
             except ValueError:
                 PrettyOutput.print(f"忽略无效的数字: {part}", OutputType.WARNING)
-    
+
     return sorted(list(selected))
 
 def _get_file_completer(root_dir: str) -> Completer:
@@ -49,58 +49,58 @@ def _get_file_completer(root_dir: str) -> Completer:
     class FileCompleter(Completer):
         def __init__(self, root_dir: str):
             self.root_dir = root_dir
-            
+
         def get_completions(self, document, complete_event):
             text = document.text_before_cursor
-            
+
             if not text:
                 for path in self._list_files(""):
                     yield Completion(path, start_position=0)
                 return
-                
+
             # 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)"""
             files = []
             search_dir = os.path.join(self.root_dir, current_dir)
-            
+
             for root, _, filenames in os.walk(search_dir):
                 for filename in filenames:
                     full_path = os.path.join(root, filename)
                     rel_path = os.path.relpath(full_path, self.root_dir)
                     if not any(part.startswith('.') for part in rel_path.split(os.sep)):
                         files.append(rel_path)
-            
+
             return sorted(files)
 
     return FileCompleter(root_dir)
 
 def _fuzzy_match_files(root_dir: str, pattern: str) -> List[str]:
     """Fuzzy match file path
-    
+
     Args:
         pattern: Matching pattern
-        
+
     Returns:
         List[str]: List of matching file paths
     """
     matches = []
-    
+
     # 将模式转换为正则表达式
     pattern = pattern.replace('.', r'\.').replace('*', '.*').replace('?', '.')
     pattern = f".*{pattern}.*"  # 允许部分匹配
     regex = re.compile(pattern, re.IGNORECASE)
-    
+
     # 遍历所有文件
     for root, _, files in os.walk(root_dir):
         for file in files:
@@ -110,7 +110,7 @@ def _fuzzy_match_files(root_dir: str, pattern: str) -> List[str]:
             if not any(part.startswith('.') for part in rel_path.split(os.sep)):
                 if regex.match(rel_path):
                     matches.append(rel_path)
-    
+
     return sorted(matches)
 
 def select_files(related_files: List[Dict[str, str]], root_dir: str) -> List[Dict[str, str]]:
@@ -127,7 +127,7 @@ def select_files(related_files: List[Dict[str, str]], root_dir: str) -> List[Dic
     if output:
         PrettyOutput.section("相关文件", OutputType.INFO)
         PrettyOutput.print(output, OutputType.INFO, lang="markdown")
-    
+
     if len(related_files) > 0:
         # Ask the user if they need to adjust the file list
         if user_confirm("是否需要调整文件列表？", False):
@@ -139,7 +139,7 @@ def select_files(related_files: List[Dict[str, str]], root_dir: str) -> List[Dic
                     selected_files = [related_files[i] for i in selected_indices]
                 else:
                     PrettyOutput.print("没有有效的文件被选择, 保持当前选择", OutputType.WARNING)
-    
+
     tips = ""
     # Ask if they need to supplement files
     if user_confirm("是否需要补充其他文件？", False):
@@ -154,23 +154,23 @@ def select_files(related_files: List[Dict[str, str]], root_dir: str) -> List[Dic
                 file_path = session.prompt(">>> ").strip()
             except KeyboardInterrupt:
                 break
-                
+
             if not file_path:
                 break
-                
+
             # Process wildcard matching
             if '*' in file_path or '?' in file_path:
                 matches = _fuzzy_match_files(root_dir, file_path)
                 if not matches:
                     PrettyOutput.print("没有找到匹配的文件", OutputType.WARNING)
                     continue
-                    
+
                 # Display matching files
                 tips = "找到以下匹配的文件:"
                 for i, path in enumerate(matches, 1):
                     tips += f"\n[{i}] {path}"
                 PrettyOutput.print(tips, OutputType.INFO)
-                    
+
                 # Let the user select
                 numbers = get_single_line_input("请选择要添加的文件编号（支持: 1,3-6格式, 按回车选择所有）").strip()
                 if numbers:
@@ -182,7 +182,7 @@ def select_files(related_files: List[Dict[str, str]], root_dir: str) -> List[Dic
                     paths_to_add = matches
             else:
                 paths_to_add = [file_path]
-            
+
             # Add selected files
             tips = "添加以下文件:"
             for path in paths_to_add:
@@ -190,7 +190,7 @@ def select_files(related_files: List[Dict[str, str]], root_dir: str) -> List[Dic
                 if not os.path.isfile(full_path):
                     tips += f"\n文件不存在: {path}"
                     continue
-                
+
                 try:
                     selected_files.append({"file": path, "reason": "I Added"})
                     tips += f"\n文件已添加: {path}"