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

jarvis/jarvis_tools/generate_new_tool.py

@@ -12,6 +12,9 @@ class generate_new_tool:
     生成并注册新的Jarvis工具。该工具会在用户数据目录下创建新的工具文件，
     并自动注册到当前的工具注册表中。适用场景：1. 需要创建新的自定义工具；
     2. 扩展Jarvis功能；3. 自动化重复性操作；4. 封装特定领域的功能。
+    重要提示：
+    1. `tool_name` 参数必须与 `tool_code` 中定义的 `name` 属性完全一致。
+    2. 在编写工具代码时，应尽量将工具执行的过程和结果打印出来，方便追踪工具的执行状态。
     """
 
     parameters = {
@@ -74,6 +77,27 @@ class generate_new_tool:
                     "stderr": f"工具名称 '{tool_name}' 不是有效的Python标识符",
                 }
 
+            # 验证工具代码中的名称是否与tool_name一致
+            import re
+
+            match = re.search(
+                r"^\s*name\s*=\s*[\"'](.+?)[\"']", tool_code, re.MULTILINE
+            )
+            if not match:
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": "无法在工具代码中找到 'name' 属性。请确保工具类中包含 'name = \"your_tool_name\"'。",
+                }
+
+            code_name = match.group(1)
+            if tool_name != code_name:
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": f"工具名称不一致：参数 'tool_name' ('{tool_name}') 与代码中的 'name' 属性 ('{code_name}') 必须相同。",
+                }
+
             # 准备工具目录
             tools_dir = Path(get_data_dir()) / "tools"
             tools_dir.mkdir(parents=True, exist_ok=True)
@@ -96,17 +120,13 @@ class generate_new_tool:
             # 注册新工具到当前的工具注册表
             success_message = f"工具 '{tool_name}' 已成功生成在 {tool_file_path}"
 
-            registration_successful = False
             if agent:
                 tool_registry = agent.get_tool_registry()
                 if tool_registry:
                     # 尝试加载并注册新工具
-                    PrettyOutput.print(
-                        f"正在注册工具 '{tool_name}'...", OutputType.INFO
-                    )
+
                     if tool_registry.register_tool_by_file(str(tool_file_path)):
-                        success_message += f"\n已成功注册到当前会话的工具注册表中"
-                        registration_successful = True
+                        success_message += "\n已成功注册到当前会话的工具注册表中"
                     else:
                         # 注册失败，删除已创建的文件
                         PrettyOutput.print(
@@ -118,20 +138,13 @@ class generate_new_tool:
                         return {
                             "success": False,
                             "stdout": "",
-                            "stderr": f"工具文件已生成，但注册失败。文件已被删除。",
+                            "stderr": "工具文件已生成，但注册失败。文件已被删除。",
                         }
                 else:
                     PrettyOutput.print(
                         "未找到工具注册表，无法自动注册工具", OutputType.WARNING
                     )
-                    success_message += f"\n注册到当前会话失败，可能需要重新启动Jarvis"
-
-            PrettyOutput.print(
-                f"工具 '{tool_name}' 创建"
-                + ("并注册" if registration_successful else "")
-                + "成功！",
-                OutputType.SUCCESS,
-            )
+                    success_message += "\n注册到当前会话失败，可能需要重新启动Jarvis"
 
             # 检查并安装缺失的依赖
             try:
@@ -159,13 +172,24 @@ class generate_new_tool:
                     try:
                         __import__(pkg)
                     except ImportError:
-                        PrettyOutput.print(
-                            f"检测到缺失依赖: {pkg}, 正在尝试安装...", OutputType.INFO
-                        )
+
                         import subprocess
+                        import sys
+                        import os
+                        from shutil import which as _which
+                        # 优先使用 uv 安装（先查 venv 内 uv，再查 PATH 中 uv），否则回退到 python -m pip
+                        if sys.platform == "win32":
+                            venv_uv = os.path.join(sys.prefix, "Scripts", "uv.exe")
+                        else:
+                            venv_uv = os.path.join(sys.prefix, "bin", "uv")
+                        uv_executable = venv_uv if os.path.exists(venv_uv) else (_which("uv") or None)
+                        if uv_executable:
+                            install_cmd = [uv_executable, "pip", "install", pkg]
+                        else:
+                            install_cmd = [sys.executable, "-m", "pip", "install", pkg]
+                        subprocess.run(install_cmd, check=True)
+
 
-                        subprocess.run(["pip", "install", pkg], check=True)
-                        PrettyOutput.print(f"成功安装依赖: {pkg}", OutputType.SUCCESS)
             except Exception as e:
                 PrettyOutput.print(f"依赖检查/安装失败: {str(e)}", OutputType.WARNING)
 
@@ -179,11 +203,9 @@ class generate_new_tool:
             # 删除已创建的文件
             if tool_file_path and tool_file_path.exists():
                 try:
-                    PrettyOutput.print(
-                        f"正在删除已创建的文件 {tool_file_path}...", OutputType.INFO
-                    )
+
                     tool_file_path.unlink()
-                    PrettyOutput.print(f"文件已删除", OutputType.SUCCESS)
+
                 except Exception as delete_error:
                     PrettyOutput.print(
                         f"删除文件失败: {str(delete_error)}", OutputType.ERROR

jarvis/jarvis_tools/read_code.py

@@ -2,6 +2,8 @@
 import os
 from typing import Any, Dict
 
+from jarvis.jarvis_utils.config import get_max_input_token_count
+from jarvis.jarvis_utils.embedding import get_context_token_count
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 
@@ -28,6 +30,29 @@ class ReadCodeTool:
         },
         "required": ["files"],
     }
+    
+    def _get_max_token_limit(self, agent: Any = None) -> int:
+        """获取基于最大窗口数量的token限制
+        
+        Args:
+            agent: Agent实例，用于获取模型组配置
+            
+        Returns:
+            int: 允许的最大token数（2/3最大窗口）
+        """
+        try:
+            # 尝试从agent获取模型组
+            model_group = None
+            if agent:
+                model_group = getattr(agent, "model_group", None)
+            
+            max_input_tokens = get_max_input_token_count(model_group)
+            # 计算2/3限制的token数
+            limit_tokens = int(max_input_tokens * 2 / 3)
+            return limit_tokens
+        except Exception:
+            # 如果获取失败，使用默认值（假设32000 token，2/3是21333）
+            return 21333
 
     def _handle_single_file(
         self, filepath: str, start_line: int = 1, end_line: int = -1, agent: Any = None
@@ -38,13 +63,14 @@ class ReadCodeTool:
             filepath (str): 文件路径
             start_line (int): 起始行号，默认为1
             end_line (int): 结束行号，默认为-1表示文件末尾
+            agent: Agent实例，用于获取上下文管理器
 
         Returns:
             Dict[str, Any]: 包含成功状态、输出内容和错误信息的字典
         """
         try:
             abs_path = os.path.abspath(filepath)
-            print(f"📖 正在读取文件: {abs_path}...")
+
             # 文件存在性检查
             if not os.path.exists(abs_path):
                 return {
@@ -62,14 +88,12 @@ class ReadCodeTool:
                 }
 
             # 读取文件内容
+            # 第一遍流式读取，仅统计总行数，避免一次性读入内存
             with open(abs_path, "r", encoding="utf-8", errors="ignore") as f:
-                lines = f.readlines()
-
-            total_lines = len(lines)
+                total_lines = sum(1 for _ in f)
 
             # 处理空文件情况
             if total_lines == 0:
-                print(f"✅ 文件读取完成: {abs_path}")
                 return {
                     "success": True,
                     "stdout": f"\n🔍 文件: {abs_path}\n📄 文件为空 (0行)\n",
@@ -93,23 +117,48 @@ class ReadCodeTool:
             )
 
             if start_line > end_line:
-                print(
-                    f"❌ 无效的行范围 [{start_line}-{end_line}] (总行数: {total_lines})"
-                )
+
                 return {
                     "success": False,
                     "stdout": "",
                     "stderr": f"无效的行范围 [{start_line}-{end_line}] (总行数: {total_lines})",
                 }
 
-            # 添加行号并构建输出内容
-            selected_lines = lines[start_line - 1 : end_line]
-            numbered_content = "".join(
-                [
-                    f"{i:4d}:{line}"
-                    for i, line in enumerate(selected_lines, start=start_line)
-                ]
-            )
+            # 读取要读取的行范围内容，计算实际token数
+            selected_content_lines = []
+            with open(abs_path, "r", encoding="utf-8", errors="ignore") as f:
+                for i, line in enumerate(f, start=1):
+                    if i < start_line:
+                        continue
+                    if i > end_line:
+                        break
+                    selected_content_lines.append(line)
+            
+            # 构建带行号的内容用于token计算（与实际输出格式一致）
+            numbered_content = "".join(f"{i:4d}:{line}" for i, line in enumerate(selected_content_lines, start=start_line))
+            
+            # 计算实际token数
+            content_tokens = get_context_token_count(numbered_content)
+            max_token_limit = self._get_max_token_limit(agent)
+            
+            # 检查单文件读取token数是否超过2/3限制
+            if content_tokens > max_token_limit:
+                read_lines = end_line - start_line + 1
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": (
+                        f"⚠️ 读取范围过大: 请求读取内容约 {content_tokens} tokens，超过限制 ({max_token_limit} tokens，约2/3最大窗口)\n"
+                        f"📊 读取范围: {read_lines} 行 (第 {start_line}-{end_line} 行，文件总行数 {total_lines})\n"
+                        f"💡 建议：\n"
+                        f"   1. 分批读取：将范围分成多个较小的批次，每批内容不超过 {max_token_limit} tokens\n"
+                        f"   2. 先定位：使用搜索或分析工具定位大致位置，再读取具体范围\n"
+                        f"   3. 缩小范围：为文件指定更精确的行号范围"
+                    ),
+                }
+
+            # 使用已读取的内容构建输出（避免重复读取）
+            numbered_content = "".join(f"{i:4d}:{line}" for i, line in enumerate(selected_content_lines, start=start_line))
 
             # 构建输出格式
             output = (
@@ -117,7 +166,11 @@ class ReadCodeTool:
                 f"📄 原始行号: {start_line}-{end_line} (共{total_lines}行) \n\n"
                 f"{numbered_content}\n\n"
             )
-            print(f"✅ 文件读取完成: {abs_path}")
+
+            # 尝试获取并附加上下文信息
+            context_info = self._get_file_context(abs_path, start_line, end_line, agent)
+            if context_info:
+                output += context_info
 
             if agent:
                 files = agent.get_user_data("files")
@@ -133,6 +186,105 @@ class ReadCodeTool:
             PrettyOutput.print(str(e), OutputType.ERROR)
             return {"success": False, "stdout": "", "stderr": f"文件读取失败: {str(e)}"}
 
+    def _get_file_context(
+        self, filepath: str, start_line: int, end_line: int, agent: Any = None
+    ) -> str:
+        """获取文件的上下文信息
+
+        Args:
+            filepath: 文件路径
+            start_line: 起始行号
+            end_line: 结束行号
+            agent: Agent实例
+
+        Returns:
+            格式化的上下文信息字符串，如果无法获取则返回空字符串
+        """
+        try:
+            # 尝试从Agent获取CodeAgent实例
+            if not agent:
+                return ""
+
+            # 通过agent获取CodeAgent实例
+            # CodeAgent在初始化时会将自身关联到agent
+            code_agent = getattr(agent, "_code_agent", None)
+            if not code_agent:
+                return ""
+
+            # 获取上下文管理器
+            context_manager = getattr(code_agent, "context_manager", None)
+            if not context_manager:
+                return ""
+
+            # 输出上下文感知日志
+            file_name = os.path.basename(filepath)
+            if start_line == end_line:
+                line_info = f"第{start_line}行"
+            else:
+                line_info = f"第{start_line}-{end_line}行"
+            PrettyOutput.print(f"🧠 正在分析代码上下文 ({file_name}, {line_info})...", OutputType.INFO)
+
+            # 确保文件已更新到上下文管理器
+            # 如果文件内容已缓存，直接使用；否则读取并更新
+            if not hasattr(context_manager, "_file_cache") or filepath not in context_manager._file_cache:
+                try:
+                    with open(filepath, "r", encoding="utf-8", errors="replace") as f:
+                        content = f.read()
+                    context_manager.update_context_for_file(filepath, content)
+                except Exception:
+                    # 如果读取失败，尝试获取已有上下文
+                    pass
+
+            # 获取编辑上下文
+            edit_context = context_manager.get_edit_context(filepath, start_line, end_line)
+
+            # 构建上下文信息
+            if not edit_context.context_summary or edit_context.context_summary == "No context available":
+                return ""
+
+            # 格式化上下文信息
+            context_lines = ["\n📋 代码上下文信息:"]
+            context_lines.append("─" * 60)
+
+            if edit_context.current_scope:
+                scope_info = f"📍 当前作用域: {edit_context.current_scope.kind} `{edit_context.current_scope.name}`"
+                if edit_context.current_scope.signature:
+                    scope_info += f"\n   └─ 签名: {edit_context.current_scope.signature}"
+                context_lines.append(scope_info)
+
+            if edit_context.used_symbols:
+                symbol_names = [s.name for s in edit_context.used_symbols[:10]]
+                symbols_str = ", ".join(f"`{name}`" for name in symbol_names)
+                more = len(edit_context.used_symbols) - 10
+                if more > 0:
+                    symbols_str += f" (还有{more}个)"
+                context_lines.append(f"🔗 使用的符号: {symbols_str}")
+
+            if edit_context.imported_symbols:
+                import_names = [s.name for s in edit_context.imported_symbols[:10]]
+                imports_str = ", ".join(f"`{name}`" for name in import_names)
+                more = len(edit_context.imported_symbols) - 10
+                if more > 0:
+                    imports_str += f" (还有{more}个)"
+                context_lines.append(f"📦 导入的符号: {imports_str}")
+
+            if edit_context.relevant_files:
+                rel_files = edit_context.relevant_files[:10]
+                files_str = "\n   ".join(f"• {os.path.relpath(f, context_manager.project_root)}" for f in rel_files)
+                more = len(edit_context.relevant_files) - 10
+                if more > 0:
+                    files_str += f"\n   ... 还有{more}个相关文件"
+                context_lines.append(f"📁 相关文件 ({len(edit_context.relevant_files)}个):\n   {files_str}")
+
+            context_lines.append("─" * 60)
+            context_lines.append("")  # 空行
+
+            return "\n".join(context_lines)
+
+        except Exception:
+            # 静默失败，不影响文件读取
+            return ""
+
     def execute(self, args: Dict) -> Dict[str, Any]:
         """执行代码读取操作
 
@@ -153,7 +305,105 @@ class ReadCodeTool:
 
             all_outputs = []
             overall_success = True
+            status_lines = []
+            total_tokens = 0  # 累计读取的token数
+            max_token_limit = self._get_max_token_limit(agent)
+
+            # 第一遍：检查所有文件的累计token数是否超过限制
+            file_read_info = []  # 存储每个文件要读取的信息
+            for file_info in args["files"]:
+                if not isinstance(file_info, dict) or "path" not in file_info:
+                    continue
+                
+                filepath = file_info["path"].strip()
+                start_line = file_info.get("start_line", 1)
+                end_line = file_info.get("end_line", -1)
+                
+                # 检查文件是否存在并计算要读取的token数
+                abs_path = os.path.abspath(filepath)
+                if not os.path.exists(abs_path):
+                    continue
+                
+                try:
+                    # 统计总行数
+                    with open(abs_path, "r", encoding="utf-8", errors="ignore") as f:
+                        total_lines = sum(1 for _ in f)
+                    
+                    if total_lines == 0:
+                        continue
+                    
+                    # 计算实际要读取的行范围
+                    if end_line == -1:
+                        actual_end_line = total_lines
+                    else:
+                        actual_end_line = (
+                            max(1, min(end_line, total_lines))
+                            if end_line >= 0
+                            else total_lines + end_line + 1
+                        )
+                    
+                    actual_start_line = (
+                        max(1, min(start_line, total_lines))
+                        if start_line >= 0
+                        else total_lines + start_line + 1
+                    )
+                    
+                    if actual_start_line <= actual_end_line:
+                        # 读取要读取的行范围内容
+                        selected_content_lines = []
+                        with open(abs_path, "r", encoding="utf-8", errors="ignore") as f:
+                            for i, line in enumerate(f, start=1):
+                                if i < actual_start_line:
+                                    continue
+                                if i > actual_end_line:
+                                    break
+                                selected_content_lines.append(line)
+                        
+                        # 构建带行号的内容用于token计算（与实际输出格式一致）
+                        numbered_content = "".join(
+                            f"{i:4d}:{line}" 
+                            for i, line in enumerate(selected_content_lines, start=actual_start_line)
+                        )
+                        
+                        # 计算实际token数
+                        content_tokens = get_context_token_count(numbered_content)
+                        
+                        file_read_info.append({
+                            "filepath": filepath,
+                            "start_line": actual_start_line,
+                            "end_line": actual_end_line,
+                            "read_lines": actual_end_line - actual_start_line + 1,
+                            "tokens": content_tokens,
+                            "file_info": file_info,
+                        })
+                        total_tokens += content_tokens
+                except Exception:
+                    continue
+
+            # 检查累计token数是否超过限制
+            if total_tokens > max_token_limit:
+                file_list = "\n   ".join(
+                    f"• {info['filepath']}: {info['tokens']} tokens ({info['read_lines']} 行, 范围: {info['start_line']}-{info['end_line']})"
+                    for info in file_read_info[:10]
+                )
+                more_files = len(file_read_info) - 10
+                if more_files > 0:
+                    file_list += f"\n   ... 还有 {more_files} 个文件"
+                
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": (
+                        f"⚠️ 累计读取范围过大: 请求累计读取内容约 {total_tokens} tokens，超过限制 ({max_token_limit} tokens，约2/3最大窗口)\n"
+                        f"📋 文件列表 ({len(file_read_info)} 个文件):\n   {file_list}\n"
+                        f"💡 建议：\n"
+                        f"   1. 分批读取：将文件分成多个批次，每批累计内容不超过 {max_token_limit} tokens\n"
+                        f"   2. 先定位：使用搜索或分析工具定位关键代码位置，再读取具体范围\n"
+                        f"   3. 缩小范围：为每个文件指定更精确的行号范围"
+                    ),
+                }
 
+            # 第二遍：实际读取文件
             for file_info in args["files"]:
                 if not isinstance(file_info, dict) or "path" not in file_info:
                     continue
@@ -167,13 +417,22 @@ class ReadCodeTool:
 
                 if result["success"]:
                     all_outputs.append(result["stdout"])
+                    status_lines.append(f"✅ {file_info['path']} 文件读取成功")
                 else:
                     all_outputs.append(f"❌ {file_info['path']}: {result['stderr']}")
+                    status_lines.append(f"❌ {file_info['path']} 文件读取失败")
                     overall_success = False
 
+            stdout_text = "\n".join(all_outputs)
+            # 仅打印每个文件的读取状态，不打印具体内容
+            try:
+                if status_lines:
+                    print("\n".join(status_lines), end="\n")
+            except Exception:
+                pass
             return {
                 "success": overall_success,
-                "stdout": "\n".join(all_outputs),
+                "stdout": stdout_text,
                 "stderr": "",
             }
 

jarvis/jarvis_tools/read_symbols.py

@@ -0,0 +1,141 @@
+# -*- coding: utf-8 -*-
+"""
+按需读取 symbols.jsonl 的工具。
+
+用途:
+- 避免Agent直接完整读取体积较大的符号表文件；
+- 通过提供符号表路径与符号名称列表，仅返回匹配的符号记录。
+
+参数:
+- symbols_file (str): 符号表文件路径（.jsonl），或项目根目录/包含 .jarvis/c2rust 的目录
+- symbols (List[str]): 需要读取的符号名称列表（支持 name 与 qualified_name 匹配）
+
+返回:
+- success (bool)
+- stdout (str): JSON文本，包含查询结果
+- stderr (str)
+"""
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, List
+
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+
+
+class ReadSymbolsTool:
+    # 文件名必须与工具名一致，便于注册表自动加载
+    name = "read_symbols"
+    description = "从symbols.jsonl按需读取指定符号的记录，避免完整加载大文件。参数包含符号表路径和符号名列表（匹配 name 与 qualified_name）（C2Rust工具专用）"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "symbols_file": {
+                "type": "string",
+                "description": "符号表文件路径（.jsonl）。若为目录，则解析为 <dir>/.jarvis/c2rust/symbols.jsonl",
+            },
+            "symbols": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "要检索的符号名称列表（支持 name 或 qualified_name 完全匹配）",
+            },
+        },
+        "required": ["symbols_file", "symbols"],
+    }
+
+    @staticmethod
+    def check() -> bool:
+        """
+        检查工具是否可用。
+        仅在 c2rust 环境中启用（通过环境变量 JARVIS_C2RUST_ENABLED 判断）。
+        """
+        return os.environ.get("JARVIS_C2RUST_ENABLED") == "1"
+
+    @staticmethod
+    def _resolve_symbols_jsonl_path(path_hint: str) -> Path:
+        """
+        解析符号表路径：
+        - 若为目录，返回 <dir>/.jarvis/c2rust/symbols.jsonl
+        - 若为文件，直接返回
+        """
+        p = Path(os.path.abspath(os.path.expanduser(path_hint)))
+        if p.is_dir():
+            candidate = p / ".jarvis" / "c2rust" / "symbols.jsonl"
+            return candidate
+        return p
+
+    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        try:
+            symbols_file_arg = args.get("symbols_file")
+            symbols_arg = args.get("symbols")
+
+            if not isinstance(symbols_file_arg, str) or not symbols_file_arg.strip():
+                return {"success": False, "stdout": "", "stderr": "缺少或无效的 symbols_file 参数"}
+
+            if not isinstance(symbols_arg, list) or not all(isinstance(s, str) for s in symbols_arg):
+                return {"success": False, "stdout": "", "stderr": "symbols 参数必须是字符串列表"}
+
+            symbols_path = self._resolve_symbols_jsonl_path(symbols_file_arg)
+            print(f"[read_symbols] Resolved symbols file path: {symbols_path}")
+            if not symbols_path.exists():
+                return {"success": False, "stdout": "", "stderr": f"符号表文件不存在: {symbols_path}"}
+            if not symbols_path.is_file():
+                return {"success": False, "stdout": "", "stderr": f"符号表路径不是文件: {symbols_path}"}
+
+            # 使用集合提升匹配效率；保持原请求顺序以便输出
+            requested: List[str] = [s.strip() for s in symbols_arg if s and s.strip()]
+            wanted_set = set(requested)
+            print(f"[read_symbols] Requested {len(wanted_set)} unique symbols.")
+
+            results: Dict[str, List[Dict[str, Any]]] = {s: [] for s in requested}
+
+            # 流式读取，避免载入整个大文件
+            with open(symbols_path, "r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        obj = json.loads(line)
+                    except Exception:
+                        continue
+
+                    name = obj.get("name") or ""
+                    qname = obj.get("qualified_name") or ""
+
+                    # 仅当命中请求的符号时才记录
+                    if name in wanted_set:
+                        results[name].append(obj)
+                    if qname in wanted_set and qname != name:
+                        results[qname].append(obj)
+
+            not_found = [s for s in requested if not results.get(s)]
+            if not_found:
+                print(f"[read_symbols] Symbols not found: {not_found}")
+            found_counts = {s: len(results.get(s, [])) for s in requested}
+
+            out_obj: Dict[str, Any] = {
+                "symbols_file": str(symbols_path),
+                "requested": requested,
+                "found_counts": found_counts,
+                "not_found": not_found,
+                "items": results,
+            }
+
+            stdout = json.dumps(out_obj, ensure_ascii=False, indent=2)
+            # 简要状态打印（不包含具体内容）
+            try:
+                status_lines = []
+                for s in requested:
+                    cnt = found_counts.get(s, 0)
+                    status_lines.append(f"[read_symbols] {s}: {cnt} 条匹配")
+                if status_lines:
+                    print("\n".join(status_lines), end="\n")
+            except Exception:
+                pass
+
+            return {"success": True, "stdout": stdout, "stderr": ""}
+
+        except Exception as e:
+            PrettyOutput.print(str(e), OutputType.ERROR)
+            return {"success": False, "stdout": "", "stderr": f"读取符号表失败: {str(e)}"}