jarvis-ai-assistant 0.1.209__py3-none-any.whl → 0.1.211__py3-none-any.whl

jarvis/jarvis_platform/human.py

@@ -52,12 +52,20 @@ class HumanPlatform(BasePlatform):
             session_info = f"(会话ID: {self.conversation_id})"
 
         if self.system_message and self.first_message:
-            prompt = f"{self.system_message}\n\n{message} {session_info}\n\n请回复:"
+            prompt = f"{self.system_message}\n\n{message} {session_info}"
             self.first_message = False
         else:
-            prompt = f"{message} {session_info}\n\n请回复:"
+            prompt = f"{message} {session_info}"
 
-        response = get_multiline_input(prompt)
+        # 将prompt复制到剪贴板
+        import subprocess
+        try:
+            subprocess.run(['xsel', '-ib'], input=prompt.encode('utf-8'), check=True)
+            PrettyOutput.print("提示已复制到剪贴板", OutputType.INFO)
+        except subprocess.CalledProcessError as e:
+            PrettyOutput.print(f"无法复制到剪贴板: {e}", OutputType.WARNING)
+
+        response = get_multiline_input(prompt + "\n\n请回复:")
         yield response
         return None
 

jarvis/jarvis_platform/tongyi.py

@@ -159,88 +159,93 @@ class TongyiPlatform(BasePlatform):
         }
 
         try:
-            response = while_success(
-                lambda: http.post(url, headers=headers, json=payload, stream=True),
+            # 使用新的stream_post接口发送消息请求，获取流式响应
+            response_stream = while_success(
+                lambda: http.stream_post(url, headers=headers, json=payload),
                 sleep_time=5,
             )
-            if response.status_code != 200:
-                raise Exception(f"HTTP {response.status_code}: {response.text}")
+
             msg_id = ""
             session_id = ""
             thinking_content = ""
             text_content = ""
             in_thinking = False
-            for line in response.iter_lines():
-                if not line:
-                    continue
+            response_data = b""
 
-                # httpx 返回字符串，requests 返回字节，需要兼容处理
-                if isinstance(line, bytes):
-                    line_str = line.decode("utf-8")
-                else:
-                    line_str = str(line)
-
-                if not line_str.startswith("data: "):
-                    continue
+            # 处理流式响应
+            for chunk in response_stream:
+                response_data += chunk
 
+                # 尝试解析SSE格式的数据
                 try:
-                    data = json.loads(line_str[6:])
-                    # 记录消息ID和会话ID
-                    if "msgId" in data:
-                        msg_id = data["msgId"]
-                    if "sessionId" in data:
-                        session_id = data["sessionId"]
-
-                    if "contents" in data and len(data["contents"]) > 0:
-                        for content in data["contents"]:
-                            if content.get("contentType") == "think":
-                                if not in_thinking:
-                                    yield "<think>\n\n"
-                                    in_thinking = True
-                                if content.get("incremental"):
-                                    tmp_content = json.loads(content.get("content"))[
-                                        "content"
-                                    ]
-                                    thinking_content += tmp_content
-                                    yield tmp_content
-                                else:
-                                    tmp_content = json.loads(content.get("content"))[
-                                        "content"
-                                    ]
-                                    if len(thinking_content) < len(tmp_content):
-                                        yield tmp_content[len(thinking_content) :]
-                                        thinking_content = tmp_content
-                                    else:
-                                        # thinking_content = "aaa</thi"
-                                        # tmp_content = "aaa"
-                                        # 应该yield nk>
-                                        # print("\n")
-                                        # print(len(thinking_content))
-                                        # print(len(tmp_content))
-                                        # print("--------------------------------")
-                                        # print(thinking_content)
-                                        # print("--------------------------------")
-                                        # print(tmp_content)
-                                        # print("--------------------------------")
-                                        yield "\r\n</think>\n"[
-                                            len(thinking_content) - len(tmp_content) :
-                                        ]
-                                        thinking_content = tmp_content
-                                    in_thinking = False
-                            elif content.get("contentType") == "text":
-                                if in_thinking:
-                                    continue
-                                if content.get("incremental"):
-                                    tmp_content = content.get("content")
-                                    text_content += tmp_content
-                                    yield tmp_content
-                                else:
-                                    tmp_content = content.get("content")
-                                    if len(text_content) < len(tmp_content):
-                                        yield tmp_content[len(text_content) :]
-                                        text_content = tmp_content
-
-                except json.JSONDecodeError:
+                    # 查找完整的数据行
+                    lines = response_data.decode("utf-8").split("\n")
+                    response_data = b""  # 重置缓冲区
+
+                    for line in lines:
+                        if not line.strip():
+                            continue
+
+                        # SSE格式的行通常以"data: "开头
+                        if line.startswith("data: "):
+                            try:
+                                data = json.loads(line[6:])
+                                # 记录消息ID和会话ID
+                                if "msgId" in data:
+                                    msg_id = data["msgId"]
+                                if "sessionId" in data:
+                                    session_id = data["sessionId"]
+
+                                if "contents" in data and len(data["contents"]) > 0:
+                                    for content in data["contents"]:
+                                        if content.get("contentType") == "think":
+                                            if not in_thinking:
+                                                yield "<think>\n\n"
+                                                in_thinking = True
+                                            if content.get("incremental"):
+                                                tmp_content = json.loads(
+                                                    content.get("content")
+                                                )["content"]
+                                                thinking_content += tmp_content
+                                                yield tmp_content
+                                            else:
+                                                tmp_content = json.loads(
+                                                    content.get("content")
+                                                )["content"]
+                                                if len(thinking_content) < len(
+                                                    tmp_content
+                                                ):
+                                                    yield tmp_content[
+                                                        len(thinking_content) :
+                                                    ]
+                                                    thinking_content = tmp_content
+                                                else:
+                                                    yield "\r\n</think>\n"[
+                                                        len(thinking_content)
+                                                        - len(tmp_content) :
+                                                    ]
+                                                    thinking_content = tmp_content
+                                                in_thinking = False
+                                        elif content.get("contentType") == "text":
+                                            if in_thinking:
+                                                continue
+                                            if content.get("incremental"):
+                                                tmp_content = content.get("content")
+                                                text_content += tmp_content
+                                                yield tmp_content
+                                            else:
+                                                tmp_content = content.get("content")
+                                                if len(text_content) < len(tmp_content):
+                                                    yield tmp_content[
+                                                        len(text_content) :
+                                                    ]
+                                                    text_content = tmp_content
+
+                            except json.JSONDecodeError:
+                                continue
+
+                except UnicodeDecodeError:
+                    # 如果解码失败，继续累积数据
                     continue
 
             self.msg_id = msg_id

jarvis/jarvis_platform/yuanbao.py

@@ -468,63 +468,66 @@ class YuanbaoPlatform(BasePlatform):
             payload["displayPrompt"] = payload["prompt"]
 
         try:
-            # 发送消息请求，获取流式响应
-            response = while_success(
-                lambda: http.post(
-                    url,
-                    headers=headers,
-                    json=payload,
-                    stream=True,
-                ),
+            # 使用新的stream_post接口发送消息请求，获取流式响应
+            response_stream = while_success(
+                lambda: http.stream_post(url, headers=headers, json=payload),
                 sleep_time=5,
             )
 
-            # 检查响应状态
-            if response.status_code != 200:
-                error_msg = f"发送消息失败，状态码: {response.status_code}"
-                if hasattr(response, "text"):
-                    error_msg += f", 响应: {response.text}"
-                raise Exception(error_msg)
-
             in_thinking = False
-
-            # 处理SSE流响应
-            for line in response.iter_lines():
-                if not line:
+            response_data = b""
+
+            # 处理流式响应
+            for chunk in response_stream:
+                response_data += chunk
+
+                # 尝试解析SSE格式的数据
+                try:
+                    # 查找完整的数据行
+                    lines = response_data.decode("utf-8").split("\n")
+                    response_data = b""  # 重置缓冲区
+
+                    for line in lines:
+                        if not line.strip():
+                            continue
+
+                        # SSE格式的行通常以"data: "开头
+                        if line.startswith("data: "):
+                            try:
+                                data_str = line[6:]  # 移除"data: "前缀
+
+                                # 检查结束标志
+                                if data_str == "[DONE]":
+                                    self.first_chat = False
+                                    return None
+
+                                data = json.loads(data_str)
+
+                                # 处理文本类型的消息
+                                if data.get("type") == "text":
+                                    if in_thinking:
+                                        yield "</think>\n"
+                                        in_thinking = False
+                                    msg = data.get("msg", "")
+                                    if msg:
+                                        yield msg
+
+                                # 处理思考中的消息
+                                elif data.get("type") == "think":
+                                    if not in_thinking:
+                                        yield "<think>\n"
+                                        in_thinking = True
+                                    think_content = data.get("content", "")
+                                    if think_content:
+                                        yield think_content
+
+                            except json.JSONDecodeError:
+                                pass
+
+                except UnicodeDecodeError:
+                    # 如果解码失败，继续累积数据
                     continue
 
-                line_str = line.decode("utf-8")
-
-                # SSE格式的行通常以"data: "开头
-                if line_str.startswith("data: "):
-                    try:
-                        data_str = line_str[6:]  # 移除"data: "前缀
-                        data = json.loads(data_str)
-
-                        # 处理文本类型的消息
-                        if data.get("type") == "text":
-                            if in_thinking:
-                                yield "</think>\n"
-                                in_thinking = False
-                            msg = data.get("msg", "")
-                            if msg:
-                                yield msg
-
-                        # 处理思考中的消息
-                        elif data.get("type") == "think":
-                            if not in_thinking:
-                                yield "<think>\n"
-                                in_thinking = True
-                            think_content = data.get("content", "")
-                            if think_content:
-                                yield think_content
-
-                    except json.JSONDecodeError:
-                        pass
-
-                # 检测结束标志
-                elif line_str == "data: [DONE]":
-                    return None
             self.first_chat = False
             return None
 

jarvis/jarvis_utils/embedding.py

@@ -1,8 +1,16 @@
 # -*- coding: utf-8 -*-
+import os
+from pathlib import Path
 from typing import List
 
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
+# 设置tiktoken缓存目录
+script_dir = Path(__file__).parent
+tiktoken_cache_dir = script_dir / "../jarvis_data/tiktoken"
+os.makedirs(tiktoken_cache_dir, exist_ok=True)
+os.environ["TIKTOKEN_CACHE_DIR"] = str(tiktoken_cache_dir.absolute())
+
 
 def get_context_token_count(text: str) -> int:
     """使用tiktoken获取文本的token数量。

jarvis/jarvis_utils/git_utils.py

@@ -9,6 +9,7 @@ Git工具模块
 - 获取最新提交的哈希值
 - 从Git差异中提取修改的行范围
 """
+import datetime
 import os
 import re
 import subprocess
@@ -344,6 +345,19 @@ def check_and_update_git_repo(repo_path: str) -> bool:
         return False
 
     try:
+        # 检查最新提交时间是否为今天
+        commit_date_result = subprocess.run(
+            ["git", "log", "-1", "--format=%cd", "--date=short"],
+            cwd=git_root,
+            capture_output=True,
+            text=True,
+        )
+        if commit_date_result.returncode == 0:
+            commit_date = commit_date_result.stdout.strip()
+            today = datetime.date.today().strftime("%Y-%m-%d")
+            if commit_date == today:
+                return False
+
         # 检查是否有未提交的修改
         if has_uncommitted_changes():
             return False
@@ -499,9 +513,16 @@ def get_recent_commits_with_files() -> List[Dict[str, Any]]:
             失败时返回空列表
     """
     try:
-        # 获取最近5次提交的基本信息
+        # 获取当前git用户名
+        current_author = subprocess.run(
+            ["git", "config", "user.name"],
+            capture_output=True,
+            text=True,
+        ).stdout.strip()
+
+        # 获取当前用户最近5次提交的基本信息
         result = subprocess.run(
-            ["git", "log", "-5", "--pretty=format:%H%n%s%n%an%n%ad"],
+            ["git", "log", "-5", "--author=" + current_author, "--pretty=format:%H%n%s%n%an%n%ad"],
             capture_output=True,
             text=True,
         )

jarvis/jarvis_utils/http.py

@@ -1,104 +1,169 @@
 # -*- coding: utf-8 -*-
 
-import requests
-from typing import Any, Dict, Optional, Union
+import httpx
+from typing import Any, Dict, Optional, Union, AsyncGenerator, Generator
 
 
-def get_session() -> requests.Session:
+def get_httpx_client() -> httpx.Client:
     """
-    获取一个永不超时的 requests.Session 对象
+    获取一个配置好的 httpx.Client 对象
 
     返回:
-        requests.Session 对象
+        httpx.Client 对象
     """
-    session = requests.Session()
-
-    # 设置默认请求头以优化连接
-    session.headers.update(
-        {"Connection": "keep-alive"}
+    client = httpx.Client(
+        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
+
+
+def get_async_httpx_client() -> httpx.AsyncClient:
+    """
+    获取一个配置好的 httpx.AsyncClient 对象
 
-    return session
+    返回:
+        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 请求方法（带重试机制，解决连接中断问题）
+# 增强版本的 HTTP 请求方法（使用 httpx 实现，带重试机制，解决连接中断问题）
 def post(
     url: str,
-    data: Optional[Union[Dict[str, Any], str, bytes]] = None,
+    data: Optional[Any] = None,
     json: Optional[Dict[str, Any]] = None,
     **kwargs,
-) -> requests.Response:
+) -> httpx.Response:
     """
-    发送增强版永不超时的 POST 请求，包含重试机制
+    发送增强版永不超时的 POST 请求，使用 httpx 实现，包含重试机制
 
     参数:
         url: 请求的 URL
         data: (可选) 请求体数据 (表单数据或原始数据)
         json: (可选) JSON 数据，会自动设置 Content-Type
-        **kwargs: 其他传递给 requests.post 的参数
+        **kwargs: 其他传递给 httpx.post 的参数
 
     返回:
-        requests.Response 对象
+        httpx.Response 对象
 
     注意:
-        此方法使用增强的永不超时设置，包含自动重试机制，适用于解决"Response ended prematurely"等连接问题
+        此方法使用 httpx 实现，包含自动重试机制，适用于解决"Response ended prematurely"等连接问题
     """
-    session = get_session()
-    return session.post(url=url, data=data, json=json, **kwargs)
+    client = get_httpx_client()
+    try:
+        response = client.post(url=url, data=data, json=json, **kwargs)
+        response.raise_for_status()
+        return response
+    finally:
+        client.close()
 
 
-def get(url: str, **kwargs) -> requests.Response:
+def get(url: str, **kwargs) -> httpx.Response:
     """
-    发送增强版永不超时的 GET 请求，包含重试机制
+    发送增强版永不超时的 GET 请求，使用 httpx 实现，包含重试机制
 
     参数:
         url: 请求的 URL
-        **kwargs: 其他传递给 requests.get 的参数
+        **kwargs: 其他传递给 httpx.get 的参数
 
     返回:
-        requests.Response 对象
+        httpx.Response 对象
 
     注意:
-        此方法使用增强的永不超时设置，包含自动重试机制，适用于解决"Response ended prematurely"等连接问题
+        此方法使用 httpx 实现，包含自动重试机制，适用于解决"Response ended prematurely"等连接问题
     """
-    session = get_session()
-    return session.get(url=url, **kwargs)
+    client = get_httpx_client()
+    try:
+        response = client.get(url=url, **kwargs)
+        response.raise_for_status()
+        return response
+    finally:
+        client.close()
 
 
-def put(
-    url: str, data: Optional[Union[Dict[str, Any], str, bytes]] = None, **kwargs
-) -> requests.Response:
+def put(url: str, data: Optional[Any] = None, **kwargs) -> httpx.Response:
     """
-    发送增强版永不超时的 PUT 请求，包含重试机制
+    发送增强版永不超时的 PUT 请求，使用 httpx 实现，包含重试机制
 
     参数:
         url: 请求的 URL
         data: (可选) 请求体数据 (表单数据或原始数据)
-        **kwargs: 其他传递给 requests.put 的参数
+        **kwargs: 其他传递给 httpx.put 的参数
 
     返回:
-        requests.Response 对象
+        httpx.Response 对象
 
     注意:
-        此方法使用增强的永不超时设置，包含自动重试机制，适用于解决"Response ended prematurely"等连接问题
+        此方法使用 httpx 实现，包含自动重试机制，适用于解决"Response ended prematurely"等连接问题
     """
-    session = get_session()
-    return session.put(url=url, data=data, **kwargs)
+    client = get_httpx_client()
+    try:
+        response = client.put(url=url, data=data, **kwargs)
+        response.raise_for_status()
+        return response
+    finally:
+        client.close()
 
 
-def delete(url: str, **kwargs) -> requests.Response:
+def delete(url: str, **kwargs) -> httpx.Response:
     """
-    发送增强版永不超时的 DELETE 请求，包含重试机制
+    发送增强版永不超时的 DELETE 请求，使用 httpx 实现，包含重试机制
 
     参数:
         url: 请求的 URL
-        **kwargs: 其他传递给 requests.delete 的参数
+        **kwargs: 其他传递给 httpx.delete 的参数
+
+    返回:
+        httpx.Response 对象
+
+    注意:
+        此方法使用 httpx 实现，包含自动重试机制，适用于解决"Response ended prematurely"等连接问题
+    """
+    client = get_httpx_client()
+    try:
+        response = client.delete(url=url, **kwargs)
+        response.raise_for_status()
+        return response
+    finally:
+        client.close()
+
+
+# 同步流式POST请求方法
+def stream_post(
+    url: str,
+    data: Optional[Any] = None,
+    json: Optional[Dict[str, Any]] = None,
+    **kwargs,
+) -> Generator[bytes, None, None]:
+    """
+    发送流式 POST 请求，使用 httpx 实现，返回标准 Generator
+
+    参数:
+        url: 请求的 URL
+        data: (可选) 请求体数据 (表单数据或原始数据)
+        json: (可选) JSON 数据，会自动设置 Content-Type
+        **kwargs: 其他传递给 httpx.post 的参数
 
     返回:
-        requests.Response 对象
+        Generator[bytes, None, None]: 字节流生成器
 
     注意:
-        此方法使用增强的永不超时设置，包含自动重试机制，适用于解决"Response ended prematurely"等连接问题
+        此方法使用 httpx 实现流式请求，适用于处理大文件下载或流式响应
     """
-    session = get_session()
-    return session.delete(url=url, **kwargs)
+    client = get_httpx_client()
+    try:
+        with client.stream("POST", url, data=data, json=json, **kwargs) as response:
+            response.raise_for_status()
+            for chunk in response.iter_bytes():
+                yield chunk
+    finally:
+        client.close()

jarvis/jarvis_utils/utils.py

@@ -66,23 +66,6 @@ def _show_welcome_message(welcome_str: str) -> None:
     PrettyOutput.print_gradient_text(jarvis_ascii_art, (0, 120, 255), (0, 255, 200))
 
 
-def _extract_huggingface_models() -> None:
-    """解压HuggingFace模型"""
-    data_dir = Path(get_data_dir())
-    script_dir = Path(os.path.dirname(os.path.dirname(__file__)))
-    hf_archive = script_dir / "jarvis_data" / "huggingface.tar.gz"
-    hf_dir = data_dir / "huggingface" / "hub"
-
-    if not hf_dir.exists() and hf_archive.exists():
-        try:
-            PrettyOutput.print("正在解压HuggingFace模型...", OutputType.INFO)
-            with tarfile.open(hf_archive, "r:gz") as tar:
-                tar.extractall(path=data_dir)
-            PrettyOutput.print("HuggingFace模型解压完成", OutputType.SUCCESS)
-        except Exception as e:
-            PrettyOutput.print(f"解压HuggingFace模型失败: {e}", OutputType.ERROR)
-
-
 def _check_git_updates() -> bool:
     """检查并更新git仓库
 
@@ -117,10 +100,7 @@ def init_env(welcome_str: str, config_file: Optional[str] = None) -> None:
     g_config_file = config_file
     load_config()
 
-    # 5. 解压模型
-    _extract_huggingface_models()
-
-    # 6. 检查git更新
+    # 5. 检查git更新
     if _check_git_updates():
         os.execv(sys.executable, [sys.executable] + sys.argv)
         sys.exit(0)

{jarvis_ai_assistant-0.1.209.dist-info → jarvis_ai_assistant-0.1.211.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jarvis-ai-assistant
-Version: 0.1.209
+Version: 0.1.211
 Summary: Jarvis: An AI assistant that uses tools to interact with the system
 Home-page: https://github.com/skyfireitdiy/Jarvis
 Author: skyfire
@@ -55,6 +55,7 @@ Requires-Dist: openai==1.78.1
 Requires-Dist: tabulate==0.9.0
 Requires-Dist: pyte==0.8.2
 Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: httpx>=0.28.1
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: black; extra == "dev"