jarvis-ai-assistant 0.3.30__py3-none-any.whl → 0.7.6__py3-none-any.whl

jarvis/jarvis_tools/sub_code_agent.py

@@ -4,22 +4,21 @@ sub_code_agent 工具
 将子任务交给 CodeAgent 执行，并返回执行结果。
 
 约定：
-- 仅接收一个参数：task
+- 必填参数：task
+- 可选参数：background
 - 不依赖父 Agent，所有配置使用系统默认与全局变量
 - 子Agent必须自动完成(auto_complete=True)且需要summary(need_summary=True)
 """
 from typing import Any, Dict, List
-import json
 
 from jarvis.jarvis_code_agent.code_agent import CodeAgent
 from jarvis.jarvis_utils.globals import delete_agent
 from jarvis.jarvis_utils.config import set_config, get_git_check_mode
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 
 class SubCodeAgentTool:
     """
-    使用 CodeAgent 托管执行子任务，执行完立即清理内部 Agent。
+    使用 CodeAgent 托管执行子任务，执行完立即清理 CodeAgent 实例。
     - 不注册至全局
     - 使用系统默认/全局配置
     - 启用自动完成与总结
@@ -27,7 +26,7 @@ class SubCodeAgentTool:
 
     # 必须与文件名一致，供 ToolRegistry 自动注册
     name = "sub_code_agent"
-    description = "将子任务交给 CodeAgent 执行，并返回执行结果（使用系统默认配置，自动完成并生成总结）。"
+    description = "将子任务交给 CodeAgent 执行并返回结果（自动完成并生成总结）。"
     parameters = {
         "type": "object",
         "properties": {
@@ -84,6 +83,7 @@ class SubCodeAgentTool:
                             parent_agent = None
                 except Exception:
                     parent_agent = None
+            parent_non_interactive = getattr(parent_agent, "non_interactive", None) if parent_agent is not None else None
             model_group = None
             use_tools: List[str] = []
             try:
@@ -108,21 +108,20 @@ class SubCodeAgentTool:
                 pass
 
             # 依据父Agent已启用工具集，推导 append_tools（作为在 CodeAgent 基础工具上的增量）
+            # 禁用 sub_agent 和 sub_code_agent，避免无限递归
+            forbidden_tools = {"sub_agent", "sub_code_agent"}
             append_tools = None
             try:
                 base_tools = [
                     "execute_script",
-                    "search_web",
-                    "ask_user",
                     "read_code",
+                    "edit_file",
                     "rewrite_file",
-                    "save_memory",
-                    "retrieve_memory",
-                    "clear_memory",
-                    "sub_code_agent",
+                    "lsp_client",
                 ]
                 if use_tools:
-                    extras = [t for t in use_tools if t not in base_tools]
+                    # 过滤掉基础工具和禁止的工具
+                    extras = [t for t in use_tools if t not in base_tools and t not in forbidden_tools]
                     append_tools = ",".join(extras) if extras else None
             except Exception:
                 append_tools = None
@@ -138,6 +137,7 @@ class SubCodeAgentTool:
                     need_summary=True,
                     append_tools=append_tools,
                     tool_group=tool_group,
+                    non_interactive=parent_non_interactive,
                 )
             except SystemExit as se:
                 # 将底层 sys.exit 转换为工具错误，避免终止进程
@@ -155,21 +155,24 @@ class SubCodeAgentTool:
 
             # 子Agent需要自动完成
             try:
-                code_agent.agent.auto_complete = True
-                # 同步父Agent工具使用集（如可用）
+                code_agent.auto_complete = True
+                # 同步父Agent工具使用集（如可用），但禁用 sub_agent 和 sub_code_agent 避免无限递归
                 if use_tools:
-                    code_agent.agent.set_use_tools(use_tools)
+                    forbidden_tools = {"sub_agent", "sub_code_agent"}
+                    filtered_tools = [t for t in use_tools if t not in forbidden_tools]
+                    if filtered_tools:
+                        code_agent.set_use_tools(filtered_tools)
                 # 同步父Agent的模型名称（如可用），以尽量保持平台与模型一致
                 if (
                     parent_agent is not None
                     and getattr(parent_agent, "model", None)
-                    and getattr(code_agent.agent, "model", None)
+                    and getattr(code_agent, "model", None)
                 ):
                     try:
                         parent_model_name = parent_agent.model.name()  # type: ignore[attr-defined]
                         if parent_model_name:
                             from typing import Any
-                            model_obj: Any = getattr(code_agent.agent, "model", None)
+                            model_obj: Any = getattr(code_agent, "model", None)
                             if model_obj is not None:
                                 model_obj.set_model_name(parent_model_name)
                                 # 模型有效性校验与回退，确保父Agent模型在子Agent平台上可用
@@ -179,10 +182,7 @@ class SubCodeAgentTool:
                                         available_names = [m for m, _ in available_models]
                                         current_model_name = model_obj.name()
                                         if current_model_name not in available_names:
-                                            PrettyOutput.print(
-                                                f"检测到子CodeAgent模型 {current_model_name} 不存在于平台 {model_obj.platform_name()} 的可用模型列表，将回退到 {available_names[0]}",
-                                                OutputType.WARNING,
-                                            )
+                                            print(f"⚠️ 检测到子CodeAgent模型 {current_model_name} 不存在于平台 {model_obj.platform_name()} 的可用模型列表，将回退到 {available_names[0]}")
                                             model_obj.set_model_name(available_names[0])
                                 except Exception:
                                     # 获取模型列表或设置模型失败时，保持原设置并继续，交由底层报错处理
@@ -194,18 +194,17 @@ class SubCodeAgentTool:
 
             # 执行子任务（无提交信息前后缀）
             ret = code_agent.run(enhanced_task, prefix="", suffix="")
-            stdout = ret if isinstance(ret, str) and ret else "任务执行完成"
 
-            # 主动清理内部 Agent，避免污染父Agent的全局状态
+            # 主动清理 CodeAgent 实例，避免污染父Agent的全局状态
             try:
-                inner_agent = code_agent.agent
-                delete_agent(inner_agent.name)
+                # CodeAgent 现在直接继承 Agent，所以直接使用 code_agent
+                delete_agent(code_agent.name)
             except Exception:
                 pass
 
             return {
                 "success": True,
-                "stdout": json.dumps({"result": stdout}, ensure_ascii=False, indent=2),
+                "stdout": ret,
                 "stderr": "",
             }
         except Exception as e:

jarvis/jarvis_tools/virtual_tty.py

@@ -3,7 +3,6 @@ import os
 import sys
 import time
 from typing import Any, Dict, TYPE_CHECKING
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 # 为了类型检查，总是导入这些模块
 if TYPE_CHECKING:
@@ -19,12 +18,7 @@ else:
 
 class VirtualTTYTool:
     name = "virtual_tty"
-    description = (
-        "控制虚拟终端执行各种操作，如启动终端、输入命令、获取输出等。"
-        + "与execute_script不同，此工具会创建一个持久的虚拟终端会话，可以连续执行多个命令，并保持终端状态。"
-        + "适用于需要交互式操作的场景，如运行需要用户输入的交互式程序（如：ssh连接、sftp传输、gdb/dlv调试等）。"
-        + "注意：Windows平台功能有限，某些Unix特有功能可能不可用。"
-    )
+    description = "控制虚拟终端执行交互式操作（如ssh、sftp、gdb等）。与execute_script不同，此工具创建持久会话，保持终端状态。Windows平台功能有限。"
     parameters = {
         "type": "object",
         "properties": {
@@ -42,19 +36,19 @@ class VirtualTTYTool:
             },
             "keys": {
                 "type": "string",
-                "description": "要发送的按键序列（仅支持单行输入，当action为send_keys时有效）",
+                "description": "要发送的按键序列（仅当action为send_keys时有效）",
             },
             "add_enter": {
                 "type": "boolean",
-                "description": "是否在单行命令末尾自动添加回车符（仅当action为send_keys时有效，默认为true）",
+                "description": "是否在命令末尾自动添加回车符（仅当action为send_keys时有效，默认true）",
             },
             "timeout": {
                 "type": "number",
-                "description": "等待输出的超时时间（秒，仅当action为send_keys或output时有效，默认为5.0）",
+                "description": "等待输出的超时时间（秒，仅当action为send_keys或output时有效，默认5.0）",
             },
             "tty_id": {
                 "type": "string",
-                "description": "虚拟终端的唯一标识符（默认为'default'）",
+                "description": "虚拟终端的唯一标识符（默认'default'）",
             },
         },
         "required": ["action"],
@@ -83,6 +77,8 @@ class VirtualTTYTool:
         # 确保agent有tty_sessions字典
         if not hasattr(agent, "tty_sessions"):
             agent.tty_sessions = {}
+        elif agent.tty_sessions is None:
+            agent.tty_sessions = {}
 
         # 如果指定的tty_id不存在，为其创建一个新的tty_data
         if tty_id not in agent.tty_sessions:
@@ -116,9 +112,7 @@ class VirtualTTYTool:
         try:
             if action == "launch":
                 if args.get("keys", "") != "":
-                    PrettyOutput.print(
-                        "启动虚拟终端时，不能同时指定 keys 参数", OutputType.ERROR
-                    )
+                    print("❌ 启动虚拟终端时，不能同时指定 keys 参数")
                     return {
                         "success": False,
                         "stdout": "",
@@ -127,9 +121,7 @@ class VirtualTTYTool:
 
                 result = self._launch_tty(agent, tty_id)
                 if not result["success"]:
-                    PrettyOutput.print(
-                        f"启动虚拟终端 [{tty_id}] 失败", OutputType.ERROR
-                    )
+                    print(f"❌ 启动虚拟终端 [{tty_id}] 失败")
                 return result
             elif action == "send_keys":
                 keys = args.get("keys", "").strip()
@@ -138,40 +130,32 @@ class VirtualTTYTool:
 
                 result = self._input_command(agent, tty_id, keys, timeout, add_enter)
                 if not result["success"]:
-                    PrettyOutput.print(
-                        f"发送按键序列到终端 [{tty_id}] 失败", OutputType.ERROR
-                    )
+                    print(f"❌ 发送按键序列到终端 [{tty_id}] 失败")
                 return result
             elif action == "output":
                 timeout = args.get("timeout", 5.0)  # 默认5秒超时
 
                 result = self._get_output(agent, tty_id, timeout)
                 if not result["success"]:
-                    PrettyOutput.print(
-                        f"获取终端 [{tty_id}] 输出失败", OutputType.ERROR
-                    )
+                    print(f"❌ 获取终端 [{tty_id}] 输出失败")
                 return result
             elif action == "close":
 
                 result = self._close_tty(agent, tty_id)
                 if not result["success"]:
-                    PrettyOutput.print(
-                        f"关闭虚拟终端 [{tty_id}] 失败", OutputType.ERROR
-                    )
+                    print(f"❌ 关闭虚拟终端 [{tty_id}] 失败")
                 return result
             elif action == "get_screen":
 
                 result = self._get_screen(agent, tty_id)
                 if not result["success"]:
-                    PrettyOutput.print(
-                        f"获取终端 [{tty_id}] 屏幕内容失败", OutputType.ERROR
-                    )
+                    print(f"❌ 获取终端 [{tty_id}] 屏幕内容失败")
                 return result
             elif action == "list":
 
                 result = self._list_ttys(agent)
                 if not result["success"]:
-                    PrettyOutput.print("获取虚拟终端列表失败", OutputType.ERROR)
+                    print("❌ 获取虚拟终端列表失败")
                 return result
             return {"success": False, "stdout": "", "stderr": "不支持的操作"}
 
@@ -231,6 +215,8 @@ class VirtualTTYTool:
                     except BlockingIOError:
                         continue
 
+                if output:
+                    print(f"📥 启动终端时的初始输出 [{tty_id}]:\n{output}")
                 return {"success": True, "stdout": output, "stderr": ""}
 
         except Exception as e:
@@ -279,7 +265,7 @@ class VirtualTTYTool:
                         line = process.stdout.readline()
                         if line:
                             agent.tty_sessions[tty_id]["output_queue"].put(line)
-                    except:
+                    except Exception:
                         break
 
             output_thread = _threading.Thread(target=read_output, daemon=True)
@@ -296,6 +282,8 @@ class VirtualTTYTool:
                 except _queue.Empty:
                     continue
 
+            if output:
+                print(f"📥 启动终端时的初始输出 [{tty_id}]:\n{output}")
             return {"success": True, "stdout": output, "stderr": ""}
 
         except Exception as e:
@@ -372,6 +360,8 @@ class VirtualTTYTool:
                             output += data.decode()
                 except BlockingIOError:
                     continue
+            if output:
+                print(f"📥 命令执行后的输出内容 [{tty_id}]:\n{output}")
             return {"success": True, "stdout": output, "stderr": ""}
 
         except Exception as e:
@@ -420,6 +410,8 @@ class VirtualTTYTool:
                 except Exception:  # queue.Empty
                     continue
 
+            if output:
+                print(f"📥 命令执行后的输出内容 [{tty_id}]:\n{output}")
             return {"success": True, "stdout": output, "stderr": ""}
 
         except Exception as e:
@@ -472,6 +464,8 @@ class VirtualTTYTool:
                                 break
                         except BlockingIOError:
                             break
+            if output:
+                print(f"📥 获取到的输出内容 [{tty_id}]:\n{output}")
             return {"success": True, "stdout": output, "stderr": ""}
 
         except Exception as e:
@@ -503,6 +497,8 @@ class VirtualTTYTool:
                 except Exception:  # queue.Empty
                     continue
 
+            if output:
+                print(f"📥 获取到的输出内容 [{tty_id}]:\n{output}")
             return {"success": True, "stdout": output, "stderr": ""}
 
         except Exception as e:
@@ -568,9 +564,35 @@ class VirtualTTYTool:
             }
 
         try:
+            process = agent.tty_sessions[tty_id]["process"]
             # 终止进程
-            agent.tty_sessions[tty_id]["process"].terminate()
-            agent.tty_sessions[tty_id]["process"].wait()
+            try:
+                import subprocess as _subprocess  # pylint: disable=import-outside-toplevel
+                process.terminate()
+                process.wait(timeout=2)
+            except _subprocess.TimeoutExpired:
+                try:
+                    process.kill()
+                    process.wait()
+                except Exception:
+                    pass
+            except Exception:
+                try:
+                    process.kill()
+                    process.wait()
+                except Exception:
+                    pass
+            finally:
+                # 确保所有文件描述符被关闭
+                try:
+                    if process.stdin:
+                        process.stdin.close()
+                    if process.stdout:
+                        process.stdout.close()
+                    if process.stderr:
+                        process.stderr.close()
+                except Exception:
+                    pass
 
             # 重置终端数据
             import queue as _queue  # pylint: disable=import-outside-toplevel

jarvis/jarvis_utils/clipboard.py

@@ -2,7 +2,6 @@
 import platform
 import subprocess
 
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 
 def copy_to_clipboard(text: str) -> None:
@@ -11,9 +10,9 @@ def copy_to_clipboard(text: str) -> None:
     参数:
         text: 要复制的文本
     """
-    PrettyOutput.print("--- 剪贴板内容开始 ---", OutputType.INFO)
+    print("ℹ️ --- 剪贴板内容开始 ---")
     print(text)
-    PrettyOutput.print("--- 剪贴板内容结束 ---", OutputType.INFO)
+    print("ℹ️ --- 剪贴板内容结束 ---")
 
     system = platform.system()
 
@@ -33,7 +32,7 @@ def copy_to_clipboard(text: str) -> None:
                 process.stdin.close()
             return
         except Exception as e:
-            PrettyOutput.print(f"使用Windows clip命令时出错: {e}", OutputType.WARNING)
+            print(f"⚠️ 使用Windows clip命令时出错: {e}")
 
     # macOS系统
     elif system == "Darwin":
@@ -49,7 +48,7 @@ def copy_to_clipboard(text: str) -> None:
                 process.stdin.close()
             return
         except Exception as e:
-            PrettyOutput.print(f"使用macOS pbcopy命令时出错: {e}", OutputType.WARNING)
+            print(f"⚠️ 使用macOS pbcopy命令时出错: {e}")
 
     # Linux系统
     else:
@@ -68,7 +67,7 @@ def copy_to_clipboard(text: str) -> None:
         except FileNotFoundError:
             pass  # xsel 未安装，继续尝试下一个
         except Exception as e:
-            PrettyOutput.print(f"使用xsel时出错: {e}", OutputType.WARNING)
+            print(f"⚠️ 使用xsel时出错: {e}")
 
         # 尝试使用 xclip
         try:
@@ -83,8 +82,6 @@ def copy_to_clipboard(text: str) -> None:
                 process.stdin.close()
             return
         except FileNotFoundError:
-            PrettyOutput.print(
-                "xsel 和 xclip 均未安装, 无法复制到剪贴板", OutputType.WARNING
-            )
+            print("⚠️ xsel 和 xclip 均未安装, 无法复制到剪贴板")
         except Exception as e:
-            PrettyOutput.print(f"使用xclip时出错: {e}", OutputType.WARNING)
+            print(f"⚠️ 使用xclip时出错: {e}")