jarvis-ai-assistant 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

jarvis/jarvis_tools/virtual_tty.py

@@ -1,11 +1,30 @@
 # -*- coding: utf-8 -*-
-import fcntl
 import os
-import pty
-import select
-import signal
+import sys
 import time
-from typing import Any, Dict
+from typing import Any, Dict, TYPE_CHECKING
+
+# 为了类型检查，总是导入这些模块
+if TYPE_CHECKING:
+    import fcntl
+    import pty
+    import select
+    import signal
+    import subprocess
+    import threading
+    import queue
+
+# 平台相关的导入
+if sys.platform != "win32":
+    import fcntl
+    import pty
+    import select
+    import signal
+else:
+    # Windows平台的导入
+    import subprocess
+    import threading
+    import queue
 
 
 class VirtualTTYTool:
@@ -14,6 +33,7 @@ class VirtualTTYTool:
         "控制虚拟终端执行各种操作，如启动终端、输入命令、获取输出等。"
         + "与execute_script不同，此工具会创建一个持久的虚拟终端会话，可以连续执行多个命令，并保持终端状态。"
         + "适用于需要交互式操作的场景，如运行需要用户输入的交互式程序（如：ssh连接、sftp传输、gdb/dlv调试等）。"
+        + "注意：Windows平台功能有限，某些Unix特有功能可能不可用。"
     )
     parameters = {
         "type": "object",
@@ -76,11 +96,21 @@ class VirtualTTYTool:
 
         # 如果指定的tty_id不存在，为其创建一个新的tty_data
         if tty_id not in agent.tty_sessions:
-            agent.tty_sessions[tty_id] = {
-                "master_fd": None,
-                "pid": None,
-                "shell": "/bin/bash",
-            }
+            if sys.platform == "win32":
+                import queue as _queue  # pylint: disable=import-outside-toplevel
+
+                agent.tty_sessions[tty_id] = {
+                    "process": None,
+                    "output_queue": _queue.Queue(),
+                    "output_thread": None,
+                    "shell": "cmd.exe",
+                }
+            else:
+                agent.tty_sessions[tty_id] = {
+                    "master_fd": None,
+                    "pid": None,
+                    "shell": "/bin/bash",
+                }
 
         action = args.get("action", "").strip().lower()
 
@@ -164,13 +194,25 @@ class VirtualTTYTool:
 
     def _launch_tty(self, agent: Any, tty_id: str) -> Dict[str, Any]:
         """启动虚拟终端"""
+        if sys.platform == "win32":
+            return self._launch_tty_windows(agent, tty_id)
+        else:
+            return self._launch_tty_unix(agent, tty_id)
+
+    def _launch_tty_unix(self, agent: Any, tty_id: str) -> Dict[str, Any]:
+        """Unix/Linux平台启动虚拟终端"""
         try:
             # 如果该ID的终端已经启动，先关闭它
             if agent.tty_sessions[tty_id]["master_fd"] is not None:
                 self._close_tty(agent, tty_id)
 
+            # 在Unix平台上导入需要的模块
+            import pty as _pty  # pylint: disable=import-outside-toplevel
+            import fcntl as _fcntl  # pylint: disable=import-outside-toplevel
+            import select as _select  # pylint: disable=import-outside-toplevel
+
             # 创建伪终端
-            pid, master_fd = pty.fork()
+            pid, master_fd = _pty.fork()
 
             if pid == 0:  # 子进程
                 # 执行shell
@@ -180,7 +222,7 @@ class VirtualTTYTool:
                 )
             else:  # 父进程
                 # 设置非阻塞模式
-                fcntl.fcntl(master_fd, fcntl.F_SETFL, os.O_NONBLOCK)
+                _fcntl.fcntl(master_fd, _fcntl.F_SETFL, os.O_NONBLOCK)
 
                 # 保存终端状态
                 agent.tty_sessions[tty_id]["master_fd"] = master_fd
@@ -191,7 +233,7 @@ class VirtualTTYTool:
                 start_time = time.time()
                 while time.time() - start_time < 2.0:  # 最多等待2秒
                     try:
-                        r, _, _ = select.select([master_fd], [], [], 0.1)
+                        r, _, _ = _select.select([master_fd], [], [], 0.1)
                         if r:
                             data = os.read(master_fd, 1024)
                             if data:
@@ -211,6 +253,74 @@ class VirtualTTYTool:
                 "stderr": f"启动虚拟终端 [{tty_id}] 失败: {str(e)}",
             }
 
+    def _launch_tty_windows(self, agent: Any, tty_id: str) -> Dict[str, Any]:
+        """Windows平台启动虚拟终端"""
+        try:
+            # 如果该ID的终端已经启动，先关闭它
+            if agent.tty_sessions[tty_id]["process"] is not None:
+                self._close_tty(agent, tty_id)
+
+            # 在Windows平台上导入需要的模块
+            import subprocess as _subprocess  # pylint: disable=import-outside-toplevel
+            import threading as _threading  # pylint: disable=import-outside-toplevel
+            import queue as _queue  # pylint: disable=import-outside-toplevel
+
+            # 创建子进程
+            process = _subprocess.Popen(
+                agent.tty_sessions[tty_id]["shell"],
+                stdin=_subprocess.PIPE,
+                stdout=_subprocess.PIPE,
+                stderr=_subprocess.STDOUT,
+                shell=True,
+                text=True,
+                bufsize=0,
+                encoding="utf-8",
+                errors="replace",
+            )
+
+            # 保存进程对象
+            agent.tty_sessions[tty_id]["process"] = process
+
+            # 创建输出读取线程
+            def read_output():
+                while True:
+                    if process is None or process.poll() is not None:
+                        break
+                    try:
+                        if process.stdout is None:
+                            break
+                        line = process.stdout.readline()
+                        if line:
+                            agent.tty_sessions[tty_id]["output_queue"].put(line)
+                    except:
+                        break
+
+            output_thread = _threading.Thread(target=read_output, daemon=True)
+            output_thread.start()
+            agent.tty_sessions[tty_id]["output_thread"] = output_thread
+
+            # 读取初始输出
+            output = ""
+            start_time = time.time()
+            while time.time() - start_time < 2.0:  # 最多等待2秒
+                try:
+                    line = agent.tty_sessions[tty_id]["output_queue"].get(timeout=0.1)
+                    output += line
+                except _queue.Empty:
+                    continue
+
+            if output:
+                print(f"📤 终端 [{tty_id}]: {output}")
+
+            return {"success": True, "stdout": output, "stderr": ""}
+
+        except Exception as e:
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"启动虚拟终端 [{tty_id}] 失败: {str(e)}",
+            }
+
     def _input_command(
         self,
         agent: Any,
@@ -225,6 +335,22 @@ class VirtualTTYTool:
             command: 要输入的单行命令
             add_enter: 是否在命令末尾添加回车符
         """
+        if sys.platform == "win32":
+            return self._input_command_windows(
+                agent, tty_id, command, timeout, add_enter
+            )
+        else:
+            return self._input_command_unix(agent, tty_id, command, timeout, add_enter)
+
+    def _input_command_unix(
+        self,
+        agent: Any,
+        tty_id: str,
+        command: str,
+        timeout: float,
+        add_enter: bool = True,
+    ) -> Dict[str, Any]:
+        """Unix/Linux平台输入命令"""
         if agent.tty_sessions[tty_id]["master_fd"] is None:
             return {
                 "success": False,
@@ -251,7 +377,9 @@ class VirtualTTYTool:
             while time.time() - start_time < timeout:
                 try:
                     # 使用select等待数据可读
-                    r, _, _ = select.select(
+                    import select as _select  # pylint: disable=import-outside-toplevel
+
+                    r, _, _ = _select.select(
                         [agent.tty_sessions[tty_id]["master_fd"]], [], [], 0.1
                     )
                     if r:
@@ -270,10 +398,68 @@ class VirtualTTYTool:
                 "stderr": f"在终端 [{tty_id}] 执行命令失败: {str(e)}",
             }
 
+    def _input_command_windows(
+        self,
+        agent: Any,
+        tty_id: str,
+        command: str,
+        timeout: float,
+        add_enter: bool = True,
+    ) -> Dict[str, Any]:
+        """Windows平台输入命令"""
+        if agent.tty_sessions[tty_id]["process"] is None:
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"虚拟终端 [{tty_id}] 未启动",
+            }
+
+        # 严格检查并拒绝多行输入
+        if "\n" in command:
+            return {"success": False, "stdout": "", "stderr": "错误：禁止多行输入"}
+
+        try:
+            # 根据add_enter参数决定是否添加回车符
+            if add_enter:
+                command = command + "\n"
+
+            # 发送命令
+            agent.tty_sessions[tty_id]["process"].stdin.write(command)
+            agent.tty_sessions[tty_id]["process"].stdin.flush()
+
+            # 等待输出
+            output = ""
+            start_time = time.time()
+            while time.time() - start_time < timeout:
+                try:
+                    line = agent.tty_sessions[tty_id]["output_queue"].get(timeout=0.1)
+                    output += line
+                except Exception:  # queue.Empty
+                    continue
+
+            print(f"📤 终端 [{tty_id}]: {output}")
+            return {"success": True, "stdout": output, "stderr": ""}
+
+        except Exception as e:
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"在终端 [{tty_id}] 执行命令失败: {str(e)}",
+            }
+
     def _get_output(
         self, agent: Any, tty_id: str, timeout: float = 5.0
     ) -> Dict[str, Any]:
         """获取终端输出"""
+        if sys.platform == "win32":
+            return self._get_output_windows(agent, tty_id, timeout)
+        else:
+            return self._get_output_unix(agent, tty_id, timeout)
+
+    def _get_output_unix(
+        self, agent: Any, tty_id: str, timeout: float = 5.0
+    ) -> Dict[str, Any]:
+        """Unix/Linux平台获取输出"""
         if agent.tty_sessions[tty_id]["master_fd"] is None:
             return {
                 "success": False,
@@ -287,7 +473,9 @@ class VirtualTTYTool:
 
             while time.time() - start_time < timeout:
                 # 使用select等待数据可读
-                r, _, _ = select.select(
+                import select as _select  # pylint: disable=import-outside-toplevel
+
+                r, _, _ = _select.select(
                     [agent.tty_sessions[tty_id]["master_fd"]], [], [], 0.1
                 )
                 if r:
@@ -313,8 +501,47 @@ class VirtualTTYTool:
                 "stderr": f"获取终端 [{tty_id}] 输出失败: {str(e)}",
             }
 
+    def _get_output_windows(
+        self, agent: Any, tty_id: str, timeout: float = 5.0
+    ) -> Dict[str, Any]:
+        """Windows平台获取输出"""
+        if agent.tty_sessions[tty_id]["process"] is None:
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"虚拟终端 [{tty_id}] 未启动",
+            }
+
+        try:
+            output = ""
+            start_time = time.time()
+
+            while time.time() - start_time < timeout:
+                try:
+                    line = agent.tty_sessions[tty_id]["output_queue"].get(timeout=0.1)
+                    output += line
+                except Exception:  # queue.Empty
+                    continue
+
+            print(f"📤 终端 [{tty_id}]: {output}")
+            return {"success": True, "stdout": output, "stderr": ""}
+
+        except Exception as e:
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"获取终端 [{tty_id}] 输出失败: {str(e)}",
+            }
+
     def _close_tty(self, agent: Any, tty_id: str) -> Dict[str, Any]:
         """关闭虚拟终端"""
+        if sys.platform == "win32":
+            return self._close_tty_windows(agent, tty_id)
+        else:
+            return self._close_tty_unix(agent, tty_id)
+
+    def _close_tty_unix(self, agent: Any, tty_id: str) -> Dict[str, Any]:
+        """Unix/Linux平台关闭终端"""
         if agent.tty_sessions[tty_id]["master_fd"] is None:
             return {
                 "success": True,
@@ -328,7 +555,9 @@ class VirtualTTYTool:
 
             # 终止子进程
             if agent.tty_sessions[tty_id]["pid"]:
-                os.kill(agent.tty_sessions[tty_id]["pid"], signal.SIGTERM)
+                import signal as _signal  # pylint: disable=import-outside-toplevel
+
+                os.kill(agent.tty_sessions[tty_id]["pid"], _signal.SIGTERM)
 
             # 重置终端数据
             agent.tty_sessions[tty_id] = {
@@ -350,8 +579,53 @@ class VirtualTTYTool:
                 "stderr": f"关闭虚拟终端 [{tty_id}] 失败: {str(e)}",
             }
 
+    def _close_tty_windows(self, agent: Any, tty_id: str) -> Dict[str, Any]:
+        """Windows平台关闭终端"""
+        if agent.tty_sessions[tty_id]["process"] is None:
+            return {
+                "success": True,
+                "stdout": f"没有正在运行的虚拟终端 [{tty_id}]",
+                "stderr": "",
+            }
+
+        try:
+            # 终止进程
+            agent.tty_sessions[tty_id]["process"].terminate()
+            agent.tty_sessions[tty_id]["process"].wait()
+
+            # 重置终端数据
+            import queue as _queue  # pylint: disable=import-outside-toplevel
+
+            agent.tty_sessions[tty_id] = {
+                "process": None,
+                "output_queue": _queue.Queue(),
+                "output_thread": None,
+                "shell": "cmd.exe",
+            }
+
+            return {
+                "success": True,
+                "stdout": f"虚拟终端 [{tty_id}] 已关闭",
+                "stderr": "",
+            }
+
+        except Exception as e:
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"关闭虚拟终端 [{tty_id}] 失败: {str(e)}",
+            }
+
     def _get_screen(self, agent: Any, tty_id: str) -> Dict[str, Any]:
         """获取当前终端屏幕内容"""
+        if sys.platform == "win32":
+            # Windows平台暂不支持获取屏幕内容
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": "Windows平台暂不支持获取屏幕内容功能",
+            }
+
         if agent.tty_sessions[tty_id]["master_fd"] is None:
             return {
                 "success": False,
@@ -371,7 +645,9 @@ class VirtualTTYTool:
             start_time = time.time()
             while time.time() - start_time < 2.0:  # 最多等待2秒
                 try:
-                    r, _, _ = select.select(
+                    import select as _select  # pylint: disable=import-outside-toplevel
+
+                    r, _, _ = _select.select(
                         [agent.tty_sessions[tty_id]["master_fd"]], [], [], 0.1
                     )
                     if r:
@@ -404,15 +680,28 @@ class VirtualTTYTool:
             active_ttys = []
 
             for tty_id, tty_data in agent.tty_sessions.items():
-                status = "活动" if tty_data["master_fd"] is not None else "关闭"
-                active_ttys.append(
-                    {
-                        "id": tty_id,
-                        "status": status,
-                        "pid": tty_data["pid"] if tty_data["pid"] else None,
-                        "shell": tty_data["shell"],
-                    }
-                )
+                if sys.platform == "win32":
+                    status = "活动" if tty_data["process"] is not None else "关闭"
+                    active_ttys.append(
+                        {
+                            "id": tty_id,
+                            "status": status,
+                            "pid": tty_data["process"].pid
+                            if tty_data["process"]
+                            else None,
+                            "shell": tty_data["shell"],
+                        }
+                    )
+                else:
+                    status = "活动" if tty_data["master_fd"] is not None else "关闭"
+                    active_ttys.append(
+                        {
+                            "id": tty_id,
+                            "status": status,
+                            "pid": tty_data["pid"] if tty_data["pid"] else None,
+                            "shell": tty_data["shell"],
+                        }
+                    )
 
             # 格式化输出
             output = "虚拟终端列表:\n"

jarvis/jarvis_utils/config.py

@@ -115,22 +115,26 @@ def get_shell_name() -> str:
     return os.path.basename(shell_path).lower()
 
 
-def _get_resolved_model_config(model_group_override: Optional[str] = None) -> Dict[str, Any]:
+def _get_resolved_model_config(
+    model_group_override: Optional[str] = None,
+) -> Dict[str, Any]:
     """
     解析并合并模型配置，处理模型组。
 
     优先级顺序:
     1. 单独的环境变量 (JARVIS_PLATFORM, JARVIS_MODEL, etc.)
-    2. JARVIS_MODEL_GROUP 中定义的组配置
+    2. JARVIS_LLM_GROUP 中定义的组配置
     3. 代码中的默认值
 
     返回:
         Dict[str, Any]: 解析后的模型配置字典
     """
     group_config = {}
-    model_group_name = model_group_override or GLOBAL_CONFIG_DATA.get("JARVIS_MODEL_GROUP")
+    model_group_name = model_group_override or GLOBAL_CONFIG_DATA.get(
+        "JARVIS_LLM_GROUP"
+    )
     # The format is a list of single-key dicts: [{'group_name': {...}}, ...]
-    model_groups = GLOBAL_CONFIG_DATA.get("JARVIS_MODEL_GROUPS", [])
+    model_groups = GLOBAL_CONFIG_DATA.get("JARVIS_LLM_GROUPS", [])
 
     if model_group_name and isinstance(model_groups, list):
         for group_item in model_groups:
@@ -202,7 +206,9 @@ def get_thinking_model_name(model_group_override: Optional[str] = None) -> str:
     """
     config = _get_resolved_model_config(model_group_override)
     # Fallback to normal model if thinking model is not specified
-    return config.get("JARVIS_THINKING_MODEL", get_normal_model_name(model_group_override))
+    return config.get(
+        "JARVIS_THINKING_MODEL", get_normal_model_name(model_group_override)
+    )
 
 
 def is_execute_tool_confirm() -> bool:
@@ -256,6 +262,12 @@ def get_pretty_output() -> bool:
     返回：
         bool: 如果启用PrettyOutput则返回True，默认为True
     """
+    import platform
+
+    # Windows系统强制设置为False
+    if platform.system() == "Windows":
+        return False
+
     return GLOBAL_CONFIG_DATA.get("JARVIS_PRETTY_OUTPUT", False) == True
 
 
@@ -334,14 +346,65 @@ def get_mcp_config() -> List[Dict[str, Any]]:
 # ==============================================================================
 
 
-def get_rag_config() -> Dict[str, Any]:
+DEFAULT_RAG_GROUPS = [
+    {
+        "text": {
+            "embedding_model": "BAAI/bge-m3",
+            "rerank_model": "BAAI/bge-reranker-v2-m3",
+            "use_bm25": True,
+            "use_rerank": True,
+        }
+    },
+    {
+        "code": {
+            "embedding_model": "Qodo/Qodo-Embed-1-7B",
+            "use_bm25": False,
+            "use_rerank": False,
+        }
+    },
+]
+
+
+def _get_resolved_rag_config(
+    rag_group_override: Optional[str] = None,
+) -> Dict[str, Any]:
     """
-    获取RAG框架的配置。
+    解析并合并RAG配置，处理RAG组。
+
+    优先级顺序:
+    1. JARVIS_RAG 中的顶级设置 (embedding_model, etc.)
+    2. JARVIS_RAG_GROUP 中定义的组配置
+    3. 代码中的默认值
 
     返回:
-        Dict[str, Any]: RAG配置字典
+        Dict[str, Any]: 解析后的RAG配置字典
     """
-    return GLOBAL_CONFIG_DATA.get("JARVIS_RAG", {})
+    group_config = {}
+    rag_group_name = rag_group_override or GLOBAL_CONFIG_DATA.get("JARVIS_RAG_GROUP")
+    rag_groups = GLOBAL_CONFIG_DATA.get("JARVIS_RAG_GROUPS", DEFAULT_RAG_GROUPS)
+
+    if rag_group_name and isinstance(rag_groups, list):
+        for group_item in rag_groups:
+            if isinstance(group_item, dict) and rag_group_name in group_item:
+                group_config = group_item[rag_group_name]
+                break
+
+    # Start with group config
+    resolved_config = group_config.copy()
+
+    # Override with specific settings from the top-level JARVIS_RAG dict
+    top_level_rag_config = GLOBAL_CONFIG_DATA.get("JARVIS_RAG", {})
+    if isinstance(top_level_rag_config, dict):
+        for key in [
+            "embedding_model",
+            "rerank_model",
+            "use_bm25",
+            "use_rerank",
+        ]:
+            if key in top_level_rag_config:
+                resolved_config[key] = top_level_rag_config[key]
+
+    return resolved_config
 
 
 def get_rag_embedding_model() -> str:
@@ -351,7 +414,8 @@ def get_rag_embedding_model() -> str:
     返回:
         str: 嵌入模型的名称
     """
-    return get_rag_config().get("embedding_model", "BAAI/bge-base-zh-v1.5")
+    config = _get_resolved_rag_config()
+    return config.get("embedding_model", "BAAI/bge-m3")
 
 
 def get_rag_rerank_model() -> str:
@@ -361,7 +425,8 @@ def get_rag_rerank_model() -> str:
     返回:
         str: rerank模型的名称
     """
-    return get_rag_config().get("rerank_model", "BAAI/bge-reranker-base")
+    config = _get_resolved_rag_config()
+    return config.get("rerank_model", "BAAI/bge-reranker-v2-m3")
 
 
 def get_rag_embedding_cache_path() -> str:
@@ -382,3 +447,25 @@ def get_rag_vector_db_path() -> str:
         str: 数据库路径
     """
     return ".jarvis/rag/vectordb"
+
+
+def get_rag_use_bm25() -> bool:
+    """
+    获取RAG是否使用BM25。
+
+    返回:
+        bool: 如果使用BM25则返回True，默认为True
+    """
+    config = _get_resolved_rag_config()
+    return config.get("use_bm25", True) is True
+
+
+def get_rag_use_rerank() -> bool:
+    """
+    获取RAG是否使用rerank。
+
+    返回:
+        bool: 如果使用rerank则返回True，默认为True
+    """
+    config = _get_resolved_rag_config()
+    return config.get("use_rerank", True) is True

jarvis/jarvis_utils/git_utils.py

@@ -214,9 +214,7 @@ def handle_commit_workflow() -> bool:
     Returns:
         bool: 提交是否成功
     """
-    if is_confirm_before_apply_patch() and not user_confirm(
-        "是否要提交代码？", default=True
-    ):
+    if is_confirm_before_apply_patch() and not user_confirm("是否要提交代码？", default=True):
         revert_change()
         return False
 
@@ -429,9 +427,7 @@ def check_and_update_git_repo(repo_path: str) -> bool:
                 if not in_venv and (
                     "Permission denied" in error_msg or "not writeable" in error_msg
                 ):
-                    if user_confirm(
-                        "检测到权限问题，是否尝试用户级安装(--user)？", True
-                    ):
+                    if user_confirm("检测到权限问题，是否尝试用户级安装(--user)？", True):
                         user_result = subprocess.run(
                             install_cmd + ["--user"],
                             cwd=git_root,
@@ -446,9 +442,7 @@ def check_and_update_git_repo(repo_path: str) -> bool:
                 PrettyOutput.print(f"代码安装失败: {error_msg}", OutputType.ERROR)
                 return False
             except Exception as e:
-                PrettyOutput.print(
-                    f"安装过程中发生意外错误: {str(e)}", OutputType.ERROR
-                )
+                PrettyOutput.print(f"安装过程中发生意外错误: {str(e)}", OutputType.ERROR)
                 return False
         # 更新检查日期文件
         with open(last_check_file, "w") as f:
@@ -482,9 +476,7 @@ def get_diff_file_list() -> List[str]:
         subprocess.run(["git", "reset"], check=True)
 
         if result.returncode != 0:
-            PrettyOutput.print(
-                f"获取差异文件列表失败: {result.stderr}", OutputType.ERROR
-            )
+            PrettyOutput.print(f"获取差异文件列表失败: {result.stderr}", OutputType.ERROR)
             return []
 
         return [f for f in result.stdout.splitlines() if f]
@@ -533,8 +525,10 @@ def get_recent_commits_with_files() -> List[Dict[str, Any]]:
             ],
             capture_output=True,
             text=True,
+            encoding="utf-8",
+            errors="replace",
         )
-        if result.returncode != 0:
+        if result.returncode != 0 or result.stdout is None:
             return []
 
         # 解析提交信息
@@ -632,9 +626,7 @@ def confirm_add_new_files() -> None:
             need_confirm = True
 
         if binary_files:
-            output_lines.append(
-                f"检测到{len(binary_files)}个二进制文件(选择N将重新检测)"
-            )
+            output_lines.append(f"检测到{len(binary_files)}个二进制文件(选择N将重新检测)")
             output_lines.append("二进制文件列表:")
             output_lines.extend(f"  - {file}" for file in binary_files)
             need_confirm = True