jarvis-ai-assistant 0.7.16__py3-none-any.whl → 1.0.2__py3-none-any.whl

jarvis/jarvis_tools/virtual_tty.py

@@ -2,7 +2,11 @@
 import os
 import sys
 import time
-from typing import Any, Dict, TYPE_CHECKING
+from typing import TYPE_CHECKING
+from typing import Any
+from typing import Dict
+
+from jarvis.jarvis_utils.output import PrettyOutput
 
 # 为了类型检查，总是导入这些模块
 if TYPE_CHECKING:
@@ -112,7 +116,7 @@ class VirtualTTYTool:
         try:
             if action == "launch":
                 if args.get("keys", "") != "":
-                    print("❌ 启动虚拟终端时，不能同时指定 keys 参数")
+                    PrettyOutput.auto_print("❌ 启动虚拟终端时，不能同时指定 keys 参数")
                     return {
                         "success": False,
                         "stdout": "",
@@ -121,7 +125,7 @@ class VirtualTTYTool:
 
                 result = self._launch_tty(agent, tty_id)
                 if not result["success"]:
-                    print(f"❌ 启动虚拟终端 [{tty_id}] 失败")
+                    PrettyOutput.auto_print(f"❌ 启动虚拟终端 [{tty_id}] 失败")
                 return result
             elif action == "send_keys":
                 keys = args.get("keys", "").strip()
@@ -130,32 +134,29 @@ class VirtualTTYTool:
 
                 result = self._input_command(agent, tty_id, keys, timeout, add_enter)
                 if not result["success"]:
-                    print(f"❌ 发送按键序列到终端 [{tty_id}] 失败")
+                    PrettyOutput.auto_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"]:
-                    print(f"❌ 获取终端 [{tty_id}] 输出失败")
+                    PrettyOutput.auto_print(f"❌ 获取终端 [{tty_id}] 输出失败")
                 return result
             elif action == "close":
-
                 result = self._close_tty(agent, tty_id)
                 if not result["success"]:
-                    print(f"❌ 关闭虚拟终端 [{tty_id}] 失败")
+                    PrettyOutput.auto_print(f"❌ 关闭虚拟终端 [{tty_id}] 失败")
                 return result
             elif action == "get_screen":
-
                 result = self._get_screen(agent, tty_id)
                 if not result["success"]:
-                    print(f"❌ 获取终端 [{tty_id}] 屏幕内容失败")
+                    PrettyOutput.auto_print(f"❌ 获取终端 [{tty_id}] 屏幕内容失败")
                 return result
             elif action == "list":
-
                 result = self._list_ttys(agent)
                 if not result["success"]:
-                    print("❌ 获取虚拟终端列表失败")
+                    PrettyOutput.auto_print("❌ 获取虚拟终端列表失败")
                 return result
             return {"success": False, "stdout": "", "stderr": "不支持的操作"}
 
@@ -181,8 +182,8 @@ class VirtualTTYTool:
                 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 pty as _pty  # pylint: disable=import-outside-toplevel
             import select as _select  # pylint: disable=import-outside-toplevel
 
             # 创建伪终端
@@ -216,7 +217,9 @@ class VirtualTTYTool:
                         continue
 
                 if output:
-                    print(f"📥 启动终端时的初始输出 [{tty_id}]:\n{output}")
+                    PrettyOutput.auto_print(
+                        f"📥 启动终端时的初始输出 [{tty_id}]:\n{output}"
+                    )
                 return {"success": True, "stdout": output, "stderr": ""}
 
         except Exception as e:
@@ -234,9 +237,9 @@ class VirtualTTYTool:
                 self._close_tty(agent, tty_id)
 
             # 在Windows平台上导入需要的模块
+            import queue as _queue  # pylint: disable=import-outside-toplevel
             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(
@@ -283,7 +286,9 @@ class VirtualTTYTool:
                     continue
 
             if output:
-                print(f"📥 启动终端时的初始输出 [{tty_id}]:\n{output}")
+                PrettyOutput.auto_print(
+                    f"📥 启动终端时的初始输出 [{tty_id}]:\n{output}"
+                )
             return {"success": True, "stdout": output, "stderr": ""}
 
         except Exception as e:
@@ -361,7 +366,9 @@ class VirtualTTYTool:
                 except BlockingIOError:
                     continue
             if output:
-                print(f"📥 命令执行后的输出内容 [{tty_id}]:\n{output}")
+                PrettyOutput.auto_print(
+                    f"📥 命令执行后的输出内容 [{tty_id}]:\n{output}"
+                )
             return {"success": True, "stdout": output, "stderr": ""}
 
         except Exception as e:
@@ -411,7 +418,9 @@ class VirtualTTYTool:
                     continue
 
             if output:
-                print(f"📥 命令执行后的输出内容 [{tty_id}]:\n{output}")
+                PrettyOutput.auto_print(
+                    f"📥 命令执行后的输出内容 [{tty_id}]:\n{output}"
+                )
             return {"success": True, "stdout": output, "stderr": ""}
 
         except Exception as e:
@@ -465,7 +474,7 @@ class VirtualTTYTool:
                         except BlockingIOError:
                             break
             if output:
-                print(f"📥 获取到的输出内容 [{tty_id}]:\n{output}")
+                PrettyOutput.auto_print(f"📥 获取到的输出内容 [{tty_id}]:\n{output}")
             return {"success": True, "stdout": output, "stderr": ""}
 
         except Exception as e:
@@ -498,7 +507,7 @@ class VirtualTTYTool:
                     continue
 
             if output:
-                print(f"📥 获取到的输出内容 [{tty_id}]:\n{output}")
+                PrettyOutput.auto_print(f"📥 获取到的输出内容 [{tty_id}]:\n{output}")
             return {"success": True, "stdout": output, "stderr": ""}
 
         except Exception as e:
@@ -568,6 +577,7 @@ class VirtualTTYTool:
             # 终止进程
             try:
                 import subprocess as _subprocess  # pylint: disable=import-outside-toplevel
+
                 process.terminate()
                 process.wait(timeout=2)
             except _subprocess.TimeoutExpired:

jarvis/jarvis_utils/__init__.py

@@ -5,6 +5,7 @@ Jarvis工具模块
 包含多种辅助函数、配置管理和常见操作。
 该模块组织为以下几个子模块：
 - config: 配置管理
+- dialogue_recorder: 对话记录器
 - embedding: 文本嵌入工具
 - git_utils: Git仓库操作
 - input: 用户输入处理
@@ -12,6 +13,7 @@ Jarvis工具模块
 - output: 输出格式化
 - utils: 通用工具
 """
+
 import os
 
 import colorama
@@ -19,6 +21,8 @@ from rich.traceback import install as install_rich_traceback
 
 # 从新模块重新导出
 # 这些导入是项目功能所必需的，可能会被动态使用
+from .dialogue_recorder import DialogueRecorder as DialogueRecorder
+
 # 初始化colorama以支持跨平台的彩色文本
 colorama.init()
 # 禁用tokenizers并行以避免多进程问题

jarvis/jarvis_utils/builtin_replace_map.py

@@ -5,7 +5,8 @@
 格式: {"标记名": {"template": "替换模板", "description": "描述信息"}}
 """
 
-from jarvis.jarvis_utils.tag import ct, ot
+from jarvis.jarvis_utils.tag import ct
+from jarvis.jarvis_utils.tag import ot
 
 BUILTIN_REPLACE_MAP = {
     "Web": {

jarvis/jarvis_utils/clipboard.py

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

jarvis/jarvis_utils/collections.py

@@ -0,0 +1,331 @@
+"""
+大小写不敏感的字典和其他集合工具类。
+
+这个模块提供了大小写不敏感的字典实现，用于处理配置键的访问，
+确保无论在何种大小写形式下都能正确访问相同的键值。
+"""
+
+from typing import Any
+from typing import Dict
+from typing import Iterator
+from typing import Mapping
+from typing import Optional
+from typing import Tuple
+from typing import Union
+
+
+class CaseInsensitiveDict(Mapping[str, Any]):
+    """
+    大小写不敏感的字典类。
+
+    这个字典类允许使用任意大小写形式的键来访问相同的值。
+    内部使用小写形式存储键，但保留了原始的键名用于迭代和显示。
+
+    示例:
+        >>> d = CaseInsensitiveDict({'Content-Type': 'text/plain'})
+        >>> d['content-type']
+        'text/plain'
+        >>> d['CONTENT-TYPE']
+        'text/plain'
+        >>> d['Content-Type']
+        'text/plain'
+        >>> list(d.keys())
+        ['Content-Type']
+    """
+
+    def __init__(
+        self, data: Optional[Union[Dict[str, Any], "CaseInsensitiveDict"]] = None
+    ) -> None:
+        """
+        初始化CaseInsensitiveDict。
+
+        Args:
+            data: 可选的初始数据，可以是字典或另一个CaseInsensitiveDict
+        """
+        self._data: Dict[str, Any] = {}
+        self._case_map: Dict[str, str] = {}  # 小写键 -> 原始键的映射
+
+        if data is not None:
+            if isinstance(data, CaseInsensitiveDict):
+                # 从另一个CaseInsensitiveDict复制
+                self._data = data._data.copy()
+                self._case_map = data._case_map.copy()
+            elif hasattr(data, "items"):
+                # 从普通字典或其他映射类型初始化
+                for key, value in data.items():
+                    self[key] = value
+
+    def __getitem__(self, key: str) -> Any:
+        """
+        通过键获取值，大小写不敏感。
+
+        Args:
+            key: 要查找的键
+
+        Returns:
+            对应的值
+
+        Raises:
+            KeyError: 如果键不存在
+        """
+        if not isinstance(key, str):
+            raise TypeError(f"键必须是字符串类型，得到 {type(key).__name__}")
+
+        lower_key = key.lower()
+        if lower_key not in self._case_map:
+            raise KeyError(key)
+
+        return self._data[lower_key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        """
+        设置键值对，大小写不敏感。
+
+        Args:
+            key: 要设置的键
+            value: 要设置的值
+        """
+        if not isinstance(key, str):
+            raise TypeError(f"键必须是字符串类型，得到 {type(key).__name__}")
+
+        lower_key = key.lower()
+        # 如果键已存在，保持原有的原始键名；否则使用新的键名
+        if lower_key not in self._case_map:
+            self._case_map[lower_key] = key  # 保留原始键名
+        self._data[lower_key] = value
+
+    def __delitem__(self, key: str) -> None:
+        """
+        删除键值对，大小写不敏感。
+
+        Args:
+            key: 要删除的键
+
+        Raises:
+            KeyError: 如果键不存在
+        """
+        if not isinstance(key, str):
+            raise TypeError(f"键必须是字符串类型，得到 {type(key).__name__}")
+
+        lower_key = key.lower()
+        if lower_key not in self._case_map:
+            raise KeyError(key)
+
+        del self._case_map[lower_key]
+        del self._data[lower_key]
+
+    def __contains__(self, key: object) -> bool:
+        """
+        检查键是否存在，大小写不敏感。
+
+        Args:
+            key: 要检查的键
+
+        Returns:
+            如果键存在返回True，否则返回False
+        """
+        if not isinstance(key, str):
+            return False
+        return key.lower() in self._case_map
+
+    def __iter__(self) -> Iterator[str]:
+        """
+        返回键的迭代器，保持原始大小写。
+
+        Returns:
+            键的迭代器
+        """
+        return iter(self._case_map.values())
+
+    def __len__(self) -> int:
+        """
+        返回字典中的键值对数量。
+
+        Returns:
+            键值对的数量
+        """
+        return len(self._data)
+
+    def __repr__(self) -> str:
+        """
+        返回字典的字符串表示。
+
+        Returns:
+            字符串表示
+        """
+        items = []
+        for original_key in self._case_map.values():
+            value = self._data[original_key.lower()]
+            items.append(f"{original_key!r}: {value!r}")
+        return f"CaseInsensitiveDict({{{', '.join(items)}}})"
+
+    def __eq__(self, other: object) -> bool:
+        """
+        比较两个字典是否相等。
+
+        Args:
+            other: 要比较的对象
+
+        Returns:
+            如果相等返回True，否则返回False
+        """
+        if not isinstance(other, CaseInsensitiveDict):
+            return NotImplemented
+        return self._data == other._data
+
+    def copy(self) -> "CaseInsensitiveDict":
+        """
+        创建字典的浅拷贝。
+
+        Returns:
+            新的CaseInsensitiveDict实例
+        """
+        return CaseInsensitiveDict(self)
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """
+        获取键对应的值，如果键不存在返回默认值。
+
+        Args:
+            key: 要查找的键
+            default: 如果键不存在时返回的默认值
+
+        Returns:
+            键对应的值或默认值
+        """
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
+    def keys(self):
+        """
+        返回所有键的视图，保持原始大小写。
+
+        Returns:
+            键的视图对象
+        """
+        from collections.abc import KeysView
+
+        return KeysView(self)
+
+    def values(self):
+        """
+        返回所有值的视图。
+
+        Returns:
+            值的视图对象
+        """
+        from collections.abc import ValuesView
+
+        return ValuesView(self)
+
+    def items(self):
+        """
+        返回所有键值对的视图，键保持原始大小写。
+
+        Returns:
+            键值对的视图对象
+        """
+        from collections.abc import ItemsView
+
+        return ItemsView(self)
+
+    def pop(self, key: str, *args: Any) -> Any:
+        """
+        移除并返回指定键的值。
+
+        Args:
+            key: 要移除的键
+            *args: 如果键不存在时的默认值（可选）
+
+        Returns:
+            键对应的值
+
+        Raises:
+            KeyError: 如果键不存在且没有提供默认值
+        """
+        if not isinstance(key, str):
+            raise TypeError(f"键必须是字符串类型，得到 {type(key).__name__}")
+
+        lower_key = key.lower()
+        if lower_key not in self._case_map:
+            if args:
+                return args[0]
+            raise KeyError(key)
+
+        self._case_map.pop(lower_key)
+        value = self._data.pop(lower_key)
+        return value
+
+    def popitem(self) -> Tuple[str, Any]:
+        """
+        移除并返回最后一个键值对。
+
+        Returns:
+            键值对
+
+        Raises:
+            KeyError: 如果字典为空
+        """
+        if not self._data:
+            raise KeyError("字典为空")
+
+        lower_key, value = self._data.popitem()
+        original_key = self._case_map.pop(lower_key)
+        return original_key, value
+
+    def setdefault(self, key: str, default: Any = None) -> Any:
+        """
+        如果键存在返回对应的值，否则设置键的值为默认值并返回默认值。
+
+        Args:
+            key: 要查找的键
+            default: 默认值
+
+        Returns:
+            键对应的值或默认值
+        """
+        try:
+            return self[key]
+        except KeyError:
+            self[key] = default
+            return default
+
+    def update(self, *args: Any, **kwargs: Any) -> None:
+        """
+        更新字典。
+
+        Args:
+            *args: 可以是另一个字典或键值对的可迭代对象
+            **kwargs: 关键字参数形式的键值对（下划线会被转换为连字符）
+        """
+        if args:
+            other = args[0]
+            if hasattr(other, "items"):
+                for key, value in other.items():
+                    self[key] = value
+            else:
+                for key, value in other:
+                    self[key] = value
+
+        for key, value in kwargs.items():
+            # 将关键字参数中的下划线转换为连字符（用于HTTP头部等场景）
+            normalized_key = key.replace("_", "-")
+            self[normalized_key] = value
+
+    def clear(self) -> None:
+        """
+        清空字典。
+        """
+        self._data.clear()
+        self._case_map.clear()
+
+    def lower_keys(self) -> Iterator[str]:
+        """
+        返回所有键的小写形式的迭代器。
+
+        Returns:
+            小写键的迭代器
+        """
+        return iter(self._case_map.keys())