jarvis-ai-assistant 0.1.208__py3-none-any.whl → 0.1.210__py3-none-any.whl

jarvis/jarvis_utils/git_utils.py

@@ -9,18 +9,19 @@ Git工具模块
 - 获取最新提交的哈希值
 - 从Git差异中提取修改的行范围
 """
+import datetime
 import os
 import re
 import subprocess
+import sys
 from typing import Any, Dict, List, Set, Tuple
 
-from jarvis.jarvis_utils.config import (get_auto_update,
-                                        is_confirm_before_apply_patch)
+from jarvis.jarvis_utils.config import is_confirm_before_apply_patch
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.utils import user_confirm
 
 
-def find_git_root(start_dir: str = ".") -> str:
+def find_git_root_and_cd(start_dir: str = ".") -> str:
     """
     切换到给定路径的Git根目录，如果不是Git仓库则初始化。
 
@@ -213,7 +214,9 @@ def handle_commit_workflow() -> bool:
     Returns:
         bool: 提交是否成功
     """
-    if is_confirm_before_apply_patch() and not user_confirm("是否要提交代码？", default=True):
+    if is_confirm_before_apply_patch() and not user_confirm(
+        "是否要提交代码？", default=True
+    ):
         revert_change()
         return False
 
@@ -337,13 +340,24 @@ def check_and_update_git_repo(repo_path: str) -> bool:
         bool: 是否执行了更新
     """
     curr_dir = os.path.abspath(os.getcwd())
-    git_root = find_git_root(repo_path)
+    git_root = find_git_root_and_cd(repo_path)
     if git_root is None:
         return False
 
     try:
-        if not get_auto_update():
-            return False
+        # 检查最新提交时间是否为今天
+        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
@@ -394,7 +408,49 @@ def check_and_update_git_repo(repo_path: str) -> bool:
                 f"Jarvis已更新到tag {remote_tag_result.stdout.strip()}",
                 OutputType.SUCCESS,
             )
-            return True
+            
+            # 执行pip安装更新代码
+            try:
+                PrettyOutput.print("正在安装更新后的代码...", OutputType.INFO)
+                
+                # 检查是否在虚拟环境中
+                in_venv = hasattr(sys, 'real_prefix') or (
+                    hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix
+                )
+                
+                # 尝试普通安装
+                install_cmd = [sys.executable, "-m", "pip", "install", "-e", "."]
+                result = subprocess.run(
+                    install_cmd,
+                    cwd=git_root,
+                    capture_output=True,
+                    text=True
+                )
+                
+                if result.returncode == 0:
+                    PrettyOutput.print("代码更新安装成功", OutputType.SUCCESS)
+                    return True
+                
+                # 处理权限错误
+                error_msg = result.stderr.strip()
+                if not in_venv and ("Permission denied" in error_msg or "not writeable" in error_msg):
+                    if user_confirm("检测到权限问题，是否尝试用户级安装(--user)？", True):
+                        user_result = subprocess.run(
+                            install_cmd + ["--user"],
+                            cwd=git_root,
+                            capture_output=True,
+                            text=True
+                        )
+                        if user_result.returncode == 0:
+                            PrettyOutput.print("用户级代码安装成功", OutputType.SUCCESS)
+                            return True
+                        error_msg = user_result.stderr.strip()
+                
+                PrettyOutput.print(f"代码安装失败: {error_msg}", OutputType.ERROR)
+                return False
+            except Exception as e:
+                PrettyOutput.print(f"安装过程中发生意外错误: {str(e)}", OutputType.ERROR)
+                return False
         return False
     except Exception as e:
         PrettyOutput.print(f"Git仓库更新检查失败: {e}", OutputType.WARNING)
@@ -424,7 +480,9 @@ def get_diff_file_list() -> List[str]:
         subprocess.run(["git", "reset"], check=True)
 
         if result.returncode != 0:
-            PrettyOutput.print(f"获取差异文件列表失败: {result.stderr}", OutputType.ERROR)
+            PrettyOutput.print(
+                f"获取差异文件列表失败: {result.stderr}", OutputType.ERROR
+            )
             return []
 
         return [f for f in result.stdout.splitlines() if f]
@@ -559,7 +617,9 @@ def confirm_add_new_files() -> None:
             need_confirm = True
 
         if binary_files:
-            output_lines.append(f"检测到{len(binary_files)}个二进制文件(选择N将重新检测)")
+            output_lines.append(
+                f"检测到{len(binary_files)}个二进制文件(选择N将重新检测)"
+            )
             output_lines.append("二进制文件列表:")
             output_lines.extend(f"  - {file}" for file in binary_files)
             need_confirm = True
@@ -580,7 +640,10 @@ def confirm_add_new_files() -> None:
         if not _check_conditions(new_files, added_lines, binary_files):
             break
 
-        if not user_confirm("是否要添加这些变更（如果不需要请修改.gitignore文件以忽略不需要的文件）？", False):
+        if not user_confirm(
+            "是否要添加这些变更（如果不需要请修改.gitignore文件以忽略不需要的文件）？",
+            False,
+        ):
             continue
 
         break

jarvis/jarvis_utils/http.py

@@ -0,0 +1,169 @@
+# -*- coding: utf-8 -*-
+
+import httpx
+from typing import Any, Dict, Optional, Union, AsyncGenerator, Generator
+
+
+def get_httpx_client() -> httpx.Client:
+    """
+    获取一个配置好的 httpx.Client 对象
+
+    返回:
+        httpx.Client 对象
+    """
+    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 对象
+
+    返回:
+        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 实现，带重试机制，解决连接中断问题）
+def post(
+    url: str,
+    data: Optional[Any] = None,
+    json: Optional[Dict[str, Any]] = None,
+    **kwargs,
+) -> httpx.Response:
+    """
+    发送增强版永不超时的 POST 请求，使用 httpx 实现，包含重试机制
+
+    参数:
+        url: 请求的 URL
+        data: (可选) 请求体数据 (表单数据或原始数据)
+        json: (可选) JSON 数据，会自动设置 Content-Type
+        **kwargs: 其他传递给 httpx.post 的参数
+
+    返回:
+        httpx.Response 对象
+
+    注意:
+        此方法使用 httpx 实现，包含自动重试机制，适用于解决"Response ended prematurely"等连接问题
+    """
+    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) -> httpx.Response:
+    """
+    发送增强版永不超时的 GET 请求，使用 httpx 实现，包含重试机制
+
+    参数:
+        url: 请求的 URL
+        **kwargs: 其他传递给 httpx.get 的参数
+
+    返回:
+        httpx.Response 对象
+
+    注意:
+        此方法使用 httpx 实现，包含自动重试机制，适用于解决"Response ended prematurely"等连接问题
+    """
+    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[Any] = None, **kwargs) -> httpx.Response:
+    """
+    发送增强版永不超时的 PUT 请求，使用 httpx 实现，包含重试机制
+
+    参数:
+        url: 请求的 URL
+        data: (可选) 请求体数据 (表单数据或原始数据)
+        **kwargs: 其他传递给 httpx.put 的参数
+
+    返回:
+        httpx.Response 对象
+
+    注意:
+        此方法使用 httpx 实现，包含自动重试机制，适用于解决"Response ended prematurely"等连接问题
+    """
+    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) -> httpx.Response:
+    """
+    发送增强版永不超时的 DELETE 请求，使用 httpx 实现，包含重试机制
+
+    参数:
+        url: 请求的 URL
+        **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 的参数
+
+    返回:
+        Generator[bytes, None, None]: 字节流生成器
+
+    注意:
+        此方法使用 httpx 实现流式请求，适用于处理大文件下载或流式响应
+    """
+    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

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 import hashlib
+import json
 import os
 import signal
 import subprocess
@@ -9,35 +10,24 @@ import time
 from pathlib import Path
 from typing import Any, Callable, Dict, Optional
 
-import yaml
+import yaml  # type: ignore
 
 from jarvis import __version__
-from jarvis.jarvis_utils.config import (get_data_dir, get_max_big_content_size,
-                                        set_global_env_data)
+from jarvis.jarvis_utils.config import (
+    get_data_dir,
+    get_max_big_content_size,
+    set_global_env_data,
+)
 from jarvis.jarvis_utils.embedding import get_context_token_count
-from jarvis.jarvis_utils.globals import (get_in_chat, get_interrupt,
-                                         set_interrupt)
+from jarvis.jarvis_utils.globals import get_in_chat, get_interrupt, set_interrupt
 from jarvis.jarvis_utils.input import get_single_line_input
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 g_config_file = None
 
 
-def init_env(welcome_str: str, config_file: Optional[str] = None) -> None:
-    """初始化环境变量从jarvis_data/env文件
-    功能：
-    1. 创建不存在的jarvis_data目录
-    2. 加载环境变量到os.environ
-    3. 处理文件读取异常
-    4. 检查git仓库状态并在落后时更新
-    5. 统计当前命令使用次数
-    6. 注册SIGINT信号处理函数
-
-    参数:
-        welcome_str: 欢迎信息字符串
-        config_file: 配置文件路径，默认为None(使用~/.jarvis/config.yaml)
-    """
-    # 保存原始信号处理函数
+def _setup_signal_handler() -> None:
+    """设置SIGINT信号处理函数"""
     original_sigint = signal.getsignal(signal.SIGINT)
 
     def sigint_handler(signum, frame):
@@ -50,7 +40,16 @@ def init_env(welcome_str: str, config_file: Optional[str] = None) -> None:
                 original_sigint(signum, frame)
 
     signal.signal(signal.SIGINT, sigint_handler)
-    count_cmd_usage()
+
+
+def _show_welcome_message(welcome_str: str) -> None:
+    """显示欢迎信息
+
+    参数:
+        welcome_str: 欢迎信息字符串
+    """
+    if not welcome_str:
+        return
 
     jarvis_ascii_art = f"""
    ██╗ █████╗ ██████╗ ██╗   ██╗██╗███████╗
@@ -64,21 +63,16 @@ def init_env(welcome_str: str, config_file: Optional[str] = None) -> None:
  https://github.com/skyfireitdiy/Jarvis
  v{__version__}
 """
-    if welcome_str:
-        PrettyOutput.print_gradient_text(jarvis_ascii_art, (0, 120, 255), (0, 255, 200))
+    PrettyOutput.print_gradient_text(jarvis_ascii_art, (0, 120, 255), (0, 255, 200))
 
-    global g_config_file
-    g_config_file = config_file
 
-    load_config()
-
-    # 现在获取最终的数据目录(可能被配置文件修改)
+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"
-
-    # 检查并解压huggingface模型
     hf_dir = data_dir / "huggingface" / "hub"
+
     if not hf_dir.exists() and hf_archive.exists():
         try:
             PrettyOutput.print("正在解压HuggingFace模型...", OutputType.INFO)
@@ -88,13 +82,47 @@ def init_env(welcome_str: str, config_file: Optional[str] = None) -> None:
         except Exception as e:
             PrettyOutput.print(f"解压HuggingFace模型失败: {e}", OutputType.ERROR)
 
-        # 检查是否是git仓库并更新
+
+def _check_git_updates() -> bool:
+    """检查并更新git仓库
+
+    返回:
+        bool: 是否需要重启进程
+    """
+    script_dir = Path(os.path.dirname(os.path.dirname(__file__)))
     from jarvis.jarvis_utils.git_utils import check_and_update_git_repo
 
-    if check_and_update_git_repo(str(script_dir)):
-        # 更新成功，用当前命令行参数启动新进程
+    return check_and_update_git_repo(str(script_dir))
+
+
+def init_env(welcome_str: str, config_file: Optional[str] = None) -> None:
+    """初始化Jarvis环境
+
+    参数:
+        welcome_str: 欢迎信息字符串
+        config_file: 配置文件路径，默认为None(使用~/.jarvis/config.yaml)
+    """
+    # 1. 设置信号处理
+    _setup_signal_handler()
+
+    # 2. 统计命令使用
+    count_cmd_usage()
+
+    # 3. 显示欢迎信息
+    if welcome_str:
+        _show_welcome_message(welcome_str)
+
+    # 4. 设置配置文件
+    global g_config_file
+    g_config_file = config_file
+    load_config()
+
+    # 5. 解压模型
+    _extract_huggingface_models()
+
+    # 6. 检查git更新
+    if _check_git_updates():
         os.execv(sys.executable, [sys.executable] + sys.argv)
-        # 如果execv失败，退出当前进程
         sys.exit(0)
 
 
@@ -111,47 +139,142 @@ def load_config():
         old_config_file = config_file_path.parent / "env"
         if old_config_file.exists():  # 旧的配置文件存在
             _read_old_config_file(old_config_file)
+        else:
+            # 生成默认配置文件
+            schema_path = (
+                Path(__file__).parent.parent / "jarvis_data" / "config_schema.json"
+            )
+            if schema_path.exists():
+                try:
+                    config_file_path.parent.mkdir(parents=True, exist_ok=True)
+                    generate_default_config(str(schema_path), str(config_file_path))
+                    PrettyOutput.print(
+                        f"已生成默认配置文件: {config_file_path}", OutputType.INFO
+                    )
+                except Exception as e:
+                    PrettyOutput.print(f"生成默认配置文件失败: {e}", OutputType.ERROR)
     else:
-        _read_config_file(config_file_path.parent, config_file_path)
+        _load_and_process_config(str(config_file_path.parent), str(config_file_path))
 
 
-def _read_config_file(jarvis_dir, config_file):
-    """读取并解析YAML格式的配置文件
+from typing import Tuple
 
-    功能：
-    1. 读取配置文件内容
-    2. 检查并添加schema声明(如果缺失)
-    3. 将配置数据保存到全局变量
-    4. 设置环境变量(如果配置中有ENV字段)
+
+def _load_config_file(config_file: str) -> Tuple[str, dict]:
+    """读取并解析YAML格式的配置文件
 
     参数:
-        jarvis_dir: Jarvis数据目录路径
         config_file: 配置文件路径
+
+    返回:
+        Tuple[str, dict]: (文件原始内容, 解析后的配置字典)
     """
     with open(config_file, "r", encoding="utf-8") as f:
         content = f.read()
         config_data = yaml.safe_load(content) or {}
-        if isinstance(config_data, dict):
-            # 检查是否已有schema声明，没有则添加
-            if "# yaml-language-server: $schema=" not in content:
-                schema_path = Path(
-                    os.path.relpath(
-                        Path(__file__).parent.parent
-                        / "jarvis_data"
-                        / "config_schema.json",
-                        start=jarvis_dir,
-                    )
-                )
-                with open(config_file, "w", encoding="utf-8") as f:
-                    f.write(f"# yaml-language-server: $schema={schema_path}\n")
-                    f.write(content)
-            # 保存到全局变量
-        set_global_env_data(config_data)
-        # 如果配置中有ENV键值对，则设置环境变量
-        if "ENV" in config_data and isinstance(config_data["ENV"], dict):
-            os.environ.update(
-                {str(k): str(v) for k, v in config_data["ENV"].items() if v is not None}
+        return content, config_data
+
+
+def _ensure_schema_declaration(
+    jarvis_dir: str, config_file: str, content: str, config_data: dict
+) -> None:
+    """确保配置文件包含schema声明
+
+    参数:
+        jarvis_dir: Jarvis数据目录路径
+        config_file: 配置文件路径
+        content: 配置文件原始内容
+        config_data: 解析后的配置字典
+    """
+    if (
+        isinstance(config_data, dict)
+        and "# yaml-language-server: $schema=" not in content
+    ):
+        schema_path = Path(
+            os.path.relpath(
+                Path(__file__).parent.parent / "jarvis_data" / "config_schema.json",
+                start=jarvis_dir,
             )
+        )
+        with open(config_file, "w", encoding="utf-8") as f:
+            f.write(f"# yaml-language-server: $schema={schema_path}\n")
+            f.write(content)
+
+
+def _process_env_variables(config_data: dict) -> None:
+    """处理配置中的环境变量
+
+    参数:
+        config_data: 解析后的配置字典
+    """
+    if "ENV" in config_data and isinstance(config_data["ENV"], dict):
+        os.environ.update(
+            {str(k): str(v) for k, v in config_data["ENV"].items() if v is not None}
+        )
+
+
+def _load_and_process_config(jarvis_dir: str, config_file: str) -> None:
+    """加载并处理配置文件
+
+    功能：
+    1. 读取配置文件
+    2. 确保schema声明存在
+    3. 保存配置到全局变量
+    4. 处理环境变量
+
+    参数:
+        jarvis_dir: Jarvis数据目录路径
+        config_file: 配置文件路径
+    """
+    content, config_data = _load_config_file(config_file)
+    _ensure_schema_declaration(jarvis_dir, config_file, content, config_data)
+    set_global_env_data(config_data)
+    _process_env_variables(config_data)
+
+
+def generate_default_config(schema_path: str, output_path: str) -> None:
+    """从schema文件生成默认的YAML格式配置文件
+
+    功能：
+    1. 从schema文件读取配置结构
+    2. 根据schema中的default值生成默认配置
+    3. 自动添加schema声明
+    4. 处理嵌套的schema结构
+    5. 保留注释和格式
+
+    参数:
+        schema_path: schema文件路径
+        output_path: 生成的配置文件路径
+    """
+    with open(schema_path, "r", encoding="utf-8") as f:
+        schema = json.load(f)
+
+    def _generate_from_schema(schema_dict: Dict[str, Any]) -> Dict[str, Any]:
+        config = {}
+        if "properties" in schema_dict:
+            for key, value in schema_dict["properties"].items():
+                if "default" in value:
+                    config[key] = value["default"]
+                elif "properties" in value:  # 处理嵌套对象
+                    config[key] = _generate_from_schema(value)
+                elif value.get("type") == "array":  # 处理列表类型
+                    config[key] = []
+        return config
+
+    default_config = _generate_from_schema(schema)
+
+    # 添加schema声明
+    rel_schema_path = Path(
+        os.path.relpath(
+            Path(schema_path),
+            start=Path(output_path).parent,
+        )
+    )
+    content = f"# yaml-language-server: $schema={rel_schema_path}\n"
+    content += yaml.dump(default_config, allow_unicode=True, sort_keys=False)
+
+    with open(output_path, "w", encoding="utf-8") as f:
+        f.write(content)
 
 
 def _read_old_config_file(config_file):