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

jarvis/jarvis_utils/globals.py

@@ -9,20 +9,26 @@
 """
 import os
 
-# 全局变量：保存最后一条消息
-last_message: str = ""
-from typing import Any, Set
+# 全局变量：保存消息历史
+from typing import Any, Dict, List, Optional
 
-import colorama
-from rich.console import Console
-from rich.theme import Theme
+message_history: List[str] = []
+MAX_HISTORY_SIZE = 50
+
+# 短期记忆存储
+short_term_memories: List[Dict[str, Any]] = []
+MAX_SHORT_TERM_MEMORIES = 100
+
+import colorama  # noqa: E402
+from rich.console import Console  # noqa: E402
+from rich.theme import Theme  # noqa: E402
 
 # 初始化colorama以支持跨平台的彩色文本
 colorama.init()
 # 禁用tokenizers并行以避免多进程问题
 os.environ["TOKENIZERS_PARALLELISM"] = "false"
 # 全局代理管理
-global_agents: Set[str] = set()
+global_agents: Dict[str, Any] = {}
 current_agent_name: str = ""
 # 表示与大模型交互的深度(>0表示正在交互)
 g_in_chat: int = 0
@@ -66,6 +72,19 @@ def make_agent_name(agent_name: str) -> str:
     return agent_name
 
 
+def get_agent(agent_name: str) -> Any:
+    """
+    获取指定名称的代理实例。
+
+    参数：
+        agent_name: 代理名称
+
+    返回：
+        Any: 代理实例，如果不存在则返回None
+    """
+    return global_agents.get(agent_name)
+
+
 def set_agent(agent_name: str, agent: Any) -> None:
     """
     设置当前代理并将其添加到全局代理集合中。
@@ -74,7 +93,7 @@ def set_agent(agent_name: str, agent: Any) -> None:
         agent_name: 代理名称
         agent: 代理对象
     """
-    global_agents.add(agent_name)
+    global_agents[agent_name] = agent
     global current_agent_name
     current_agent_name = agent_name
 
@@ -101,7 +120,7 @@ def delete_agent(agent_name: str) -> None:
         agent_name: 要删除的代理名称
     """
     if agent_name in global_agents:
-        global_agents.remove(agent_name)
+        del global_agents[agent_name]
         global current_agent_name
         current_agent_name = ""
 
@@ -156,13 +175,18 @@ def get_interrupt() -> int:
 
 def set_last_message(message: str) -> None:
     """
-    设置最后一条消息。
+    将消息添加到历史记录中。
 
     参数:
         message: 要保存的消息
     """
-    global last_message
-    last_message = message
+    global message_history
+    if message:
+        # 避免重复添加
+        if not message_history or message_history[-1] != message:
+            message_history.append(message)
+            if len(message_history) > MAX_HISTORY_SIZE:
+                message_history.pop(0)
 
 
 def get_last_message() -> str:
@@ -170,13 +194,146 @@ def get_last_message() -> str:
     获取最后一条消息。
 
     返回:
-        str: 最后一条消息
+        str: 最后一条消息，如果历史记录为空则返回空字符串
     """
-    return last_message
+    global message_history
+    if message_history:
+        return message_history[-1]
+    return ""
+
+
+def get_message_history() -> List[str]:
     """
-    获取当前中断信号状态。
+    获取完整的消息历史记录。
 
     返回:
-        int: 当前中断计数
+        List[str]: 消息历史列表
     """
-    return g_interrupt
+    global message_history
+    return message_history
+
+
+def add_short_term_memory(memory_data: Dict[str, Any]) -> None:
+    """
+    添加短期记忆到全局存储。
+
+    参数:
+        memory_data: 包含记忆信息的字典
+    """
+    global short_term_memories
+    short_term_memories.append(memory_data)
+    # 如果超过最大数量，删除最旧的记忆
+    if len(short_term_memories) > MAX_SHORT_TERM_MEMORIES:
+        short_term_memories.pop(0)
+
+
+def get_short_term_memories(tags: Optional[List[str]] = None) -> List[Dict[str, Any]]:
+    """
+    获取短期记忆，可选择按标签过滤。
+
+    参数:
+        tags: 用于过滤的标签列表（可选）
+
+    返回:
+        List[Dict[str, Any]]: 符合条件的短期记忆列表，按创建时间降序排列
+    """
+    global short_term_memories
+
+    # 获取记忆副本
+    memories_copy = short_term_memories.copy()
+
+    # 按标签过滤（如果提供了标签）
+    if tags:
+        filtered_memories = []
+        for memory in memories_copy:
+            memory_tags = memory.get("tags", [])
+            if any(tag in memory_tags for tag in tags):
+                filtered_memories.append(memory)
+        memories_copy = filtered_memories
+
+    # 按创建时间排序（最新的在前）
+    memories_copy.sort(key=lambda x: x.get("created_at", ""), reverse=True)
+
+    return memories_copy
+
+
+def clear_short_term_memories() -> None:
+    """
+    清空所有短期记忆。
+    """
+    global short_term_memories
+    short_term_memories.clear()
+
+
+def get_all_memory_tags() -> Dict[str, List[str]]:
+    """
+    获取所有记忆类型中的标签集合。
+    每个类型最多返回200个标签，超过时随机提取。
+
+    返回:
+        Dict[str, List[str]]: 按记忆类型分组的标签列表
+    """
+    from pathlib import Path
+    import json
+    import random
+    from jarvis.jarvis_utils.config import get_data_dir
+
+    tags_by_type: Dict[str, List[str]] = {
+        "short_term": [],
+        "project_long_term": [],
+        "global_long_term": [],
+    }
+
+    MAX_TAGS_PER_TYPE = 200
+
+    # 获取短期记忆标签
+    short_term_tags = set()
+    for memory in short_term_memories:
+        short_term_tags.update(memory.get("tags", []))
+    short_term_tags_list = sorted(list(short_term_tags))
+    if len(short_term_tags_list) > MAX_TAGS_PER_TYPE:
+        tags_by_type["short_term"] = sorted(
+            random.sample(short_term_tags_list, MAX_TAGS_PER_TYPE)
+        )
+    else:
+        tags_by_type["short_term"] = short_term_tags_list
+
+    # 获取项目长期记忆标签
+    project_memory_dir = Path(".jarvis/memory")
+    if project_memory_dir.exists():
+        project_tags = set()
+        for memory_file in project_memory_dir.glob("*.json"):
+            try:
+                with open(memory_file, "r", encoding="utf-8") as f:
+                    memory_data = json.load(f)
+                    project_tags.update(memory_data.get("tags", []))
+            except Exception:
+                pass
+        project_tags_list = sorted(list(project_tags))
+        if len(project_tags_list) > MAX_TAGS_PER_TYPE:
+            tags_by_type["project_long_term"] = sorted(
+                random.sample(project_tags_list, MAX_TAGS_PER_TYPE)
+            )
+        else:
+            tags_by_type["project_long_term"] = project_tags_list
+
+    # 获取全局长期记忆标签
+    global_memory_dir = Path(get_data_dir()) / "memory" / "global_long_term"
+    if global_memory_dir.exists():
+        global_tags = set()
+        for memory_file in global_memory_dir.glob("*.json"):
+            try:
+                with open(memory_file, "r", encoding="utf-8") as f:
+                    memory_data = json.load(f)
+                    global_tags.update(memory_data.get("tags", []))
+            except Exception:
+                pass
+        global_tags_list = sorted(list(global_tags))
+        if len(global_tags_list) > MAX_TAGS_PER_TYPE:
+            tags_by_type["global_long_term"] = sorted(
+                random.sample(global_tags_list, MAX_TAGS_PER_TYPE)
+            )
+        else:
+            tags_by_type["global_long_term"] = global_tags_list
+
+    return tags_by_type

jarvis/jarvis_utils/http.py

@@ -1,140 +1,120 @@
 # -*- coding: utf-8 -*-
 
-import httpx
-from typing import Any, Dict, Optional, Union, AsyncGenerator, Generator
+import requests  # type: ignore[import-untyped]
+from typing import Any, Dict, Optional, Generator
 
 
-def get_httpx_client() -> httpx.Client:
+def get_requests_session() -> requests.Session:
     """
-    获取一个配置好的 httpx.Client 对象
+    获取一个配置好的 requests.Session 对象
 
     返回:
-        httpx.Client 对象
+        requests.Session 对象
     """
-    client = httpx.Client(
-        timeout=httpx.Timeout(None),  # 永不超时
-        headers={
+    session = requests.Session()
+    session.headers.update(
+        {
             "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36",
-        },
+        }
     )
-    return client
+    return session
 
 
-def get_async_httpx_client() -> httpx.AsyncClient:
-    """
-    获取一个配置好的 httpx.AsyncClient 对象
-
-    返回:
-        httpx.AsyncClient 对象
-    """
-    client = httpx.AsyncClient(
-        timeout=httpx.Timeout(None),  # 永不超时
-        headers={
-            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36",
-        },
-    )
-    return client
-
-
-# 增强版本的 HTTP 请求方法（使用 httpx 实现，带重试机制，解决连接中断问题）
+# 增强版本的 HTTP 请求方法（使用 requests 实现）
 def post(
     url: str,
     data: Optional[Any] = None,
     json: Optional[Dict[str, Any]] = None,
     **kwargs,
-) -> httpx.Response:
+) -> requests.Response:
     """
-    发送增强版永不超时的 POST 请求，使用 httpx 实现，包含重试机制
+    发送增强版永不超时的 POST 请求，使用 requests 实现
 
     参数:
         url: 请求的 URL
         data: (可选) 请求体数据 (表单数据或原始数据)
         json: (可选) JSON 数据，会自动设置 Content-Type
-        **kwargs: 其他传递给 httpx.post 的参数
+        **kwargs: 其他传递给 requests.post 的参数
 
     返回:
-        httpx.Response 对象
+        requests.Response 对象
 
     注意:
-        此方法使用 httpx 实现，包含自动重试机制，适用于解决"Response ended prematurely"等连接问题
+        此方法使用 requests 实现。要实现重试，请考虑使用 Session 和 HTTPAdapter。
+        永不超时通过 timeout=None 设置。
     """
-    client = get_httpx_client()
-    try:
-        response = client.post(url=url, data=data, json=json, **kwargs)
+    kwargs.setdefault("timeout", None)
+    with get_requests_session() as session:
+        response = session.post(url=url, data=data, json=json, **kwargs)
         response.raise_for_status()
         return response
-    finally:
-        client.close()
 
 
-def get(url: str, **kwargs) -> httpx.Response:
+def get(url: str, **kwargs) -> requests.Response:
     """
-    发送增强版永不超时的 GET 请求，使用 httpx 实现，包含重试机制
+    发送增强版永不超时的 GET 请求，使用 requests 实现
 
     参数:
         url: 请求的 URL
-        **kwargs: 其他传递给 httpx.get 的参数
+        **kwargs: 其他传递给 requests.get 的参数
 
     返回:
-        httpx.Response 对象
+        requests.Response 对象
 
     注意:
-        此方法使用 httpx 实现，包含自动重试机制，适用于解决"Response ended prematurely"等连接问题
+        此方法使用 requests 实现。
+        永不超时通过 timeout=None 设置。
     """
-    client = get_httpx_client()
-    try:
-        response = client.get(url=url, **kwargs)
+    kwargs.setdefault("timeout", None)
+    with get_requests_session() as session:
+        response = session.get(url=url, **kwargs)
         response.raise_for_status()
         return response
-    finally:
-        client.close()
 
 
-def put(url: str, data: Optional[Any] = None, **kwargs) -> httpx.Response:
+def put(url: str, data: Optional[Any] = None, **kwargs) -> requests.Response:
     """
-    发送增强版永不超时的 PUT 请求，使用 httpx 实现，包含重试机制
+    发送增强版永不超时的 PUT 请求，使用 requests 实现
 
     参数:
         url: 请求的 URL
         data: (可选) 请求体数据 (表单数据或原始数据)
-        **kwargs: 其他传递给 httpx.put 的参数
+        **kwargs: 其他传递给 requests.put 的参数
 
     返回:
-        httpx.Response 对象
+        requests.Response 对象
 
     注意:
-        此方法使用 httpx 实现，包含自动重试机制，适用于解决"Response ended prematurely"等连接问题
+        此方法使用 requests 实现。
+        永不超时通过 timeout=None 设置。
     """
-    client = get_httpx_client()
-    try:
-        response = client.put(url=url, data=data, **kwargs)
+    kwargs.setdefault("timeout", None)
+    with get_requests_session() as session:
+        response = session.put(url=url, data=data, **kwargs)
         response.raise_for_status()
         return response
-    finally:
-        client.close()
 
 
-def delete(url: str, **kwargs) -> httpx.Response:
+def delete(url: str, **kwargs) -> requests.Response:
     """
-    发送增强版永不超时的 DELETE 请求，使用 httpx 实现，包含重试机制
+    发送增强版永不超时的 DELETE 请求，使用 requests 实现
 
     参数:
         url: 请求的 URL
-        **kwargs: 其他传递给 httpx.delete 的参数
+        **kwargs: 其他传递给 requests.delete 的参数
 
     返回:
-        httpx.Response 对象
+        requests.Response 对象
 
     注意:
-        此方法使用 httpx 实现，包含自动重试机制，适用于解决"Response ended prematurely"等连接问题
+        此方法使用 requests 实现。
+        永不超时通过 timeout=None 设置。
     """
-    client = get_httpx_client()
-    try:
-        response = client.delete(url=url, **kwargs)
+    kwargs.setdefault("timeout", None)
+    with get_requests_session() as session:
+        response = session.delete(url=url, **kwargs)
         response.raise_for_status()
         return response
-    finally:
-        client.close()
 
 
 # 同步流式POST请求方法
@@ -143,27 +123,26 @@ def stream_post(
     data: Optional[Any] = None,
     json: Optional[Dict[str, Any]] = None,
     **kwargs,
-) -> Generator[bytes, None, None]:
+) -> Generator[str, None, None]:
     """
-    发送流式 POST 请求，使用 httpx 实现，返回标准 Generator
+    发送流式 POST 请求，使用 requests 实现，返回解码后的字符串行生成器
 
     参数:
         url: 请求的 URL
         data: (可选) 请求体数据 (表单数据或原始数据)
         json: (可选) JSON 数据，会自动设置 Content-Type
-        **kwargs: 其他传递给 httpx.post 的参数
+        **kwargs: 其他传递给 requests.post 的参数
 
     返回:
-        Generator[bytes, None, None]: 字节流生成器
+        Generator[str, None, None]: 字符串行生成器
 
     注意:
-        此方法使用 httpx 实现流式请求，适用于处理大文件下载或流式响应
+        此方法使用 requests 实现流式请求，适用于处理大文件下载或流式响应
     """
-    client = get_httpx_client()
-    try:
-        with client.stream("POST", url, data=data, json=json, **kwargs) as response:
+    kwargs.setdefault("timeout", None)
+    with get_requests_session() as session:
+        with session.post(url, data=data, json=json, stream=True, **kwargs) as response:
             response.raise_for_status()
-            for chunk in response.iter_bytes():
-                yield chunk
-    finally:
-        client.close()
+            for line in response.iter_lines(chunk_size=1):
+                if line:
+                    yield line.decode("utf-8", errors="ignore")