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

jarvis/jarvis_git_utils/git_commiter.py

@@ -1,12 +1,11 @@
 # -*- coding: utf-8 -*-
-import argparse
 import os
 import re
 import subprocess
-import sys
 import tempfile
 from typing import Any, Dict, Optional
 
+import typer
 import yaml  # type: ignore
 
 from jarvis.jarvis_platform.registry import PlatformRegistry
@@ -16,10 +15,13 @@ from jarvis.jarvis_utils.git_utils import (
     find_git_root_and_cd,
     has_uncommitted_changes,
 )
+from jarvis.jarvis_utils.globals import get_agent, current_agent_name
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.tag import ct, ot
 from jarvis.jarvis_utils.utils import init_env, is_context_overflow
 
+app = typer.Typer(help="Git提交工具")
+
 
 class GitCommitTool:
     name = "git_commit_agent"
@@ -79,11 +81,10 @@ class GitCommitTool:
 
     def _stage_changes(self) -> None:
         """Stage all changes for commit"""
-        print("📁 正在添加文件到提交...")
+
         subprocess.Popen(
             ["git", "add", "."], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
         ).wait()
-        print("✅ 添加文件到提交")
 
     def execute(self, args: Dict) -> Dict[str, Any]:
         """Execute automatic commit process with support for multi-line messages and special characters"""
@@ -104,17 +105,16 @@ class GitCommitTool:
             if not has_uncommitted_changes():
                 return {"success": True, "stdout": "No changes to commit", "stderr": ""}
 
-            print("🚀 正在初始化提交流程...")
             self._stage_changes()
 
             # 获取差异
-            print("📊 正在获取代码差异...")
+
             # 获取文件列表
             files_cmd = ["git", "diff", "--cached", "--name-only"]
             process = subprocess.Popen(
-                files_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+                files_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
             )
-            files_output = process.communicate()[0].decode()
+            files_output = process.communicate()[0]
             files = [f.strip() for f in files_output.split("\n") if f.strip()]
             file_count = len(files)
 
@@ -123,20 +123,21 @@ class GitCommitTool:
                 ["git", "diff", "--cached", "--exit-code"],
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
+                text=True,
             )
-            diff = process.communicate()[0].decode(errors="ignore")
-            print(f"✅ 获取差异 ({file_count} 个文件)")
+            diff = process.communicate()[0]
+
             try:
                 temp_diff_file_path = None
                 # 生成提交信息
-                print("✨ 正在生成提交消息...")
+                PrettyOutput.print("正在生成提交消息...", OutputType.INFO)
 
                 # 准备提示信息
                 custom_prompt = get_git_commit_prompt()
                 base_prompt = (
                     custom_prompt
                     if custom_prompt
-                    else f"""根据代码差异生成提交信息：
+                    else """根据代码差异生成提交信息：
                 提交信息应使用中文书写
 # 格式模板
 必须使用以下格式：
@@ -161,22 +162,111 @@ commit信息
 {ct("COMMIT_MESSAGE")}
                 """
 
-                # 获取模型并尝试上传文件
-                platform = PlatformRegistry().get_normal_platform()
+                # 优先从调用方传入的 agent 获取平台与模型
+                agent_from_args = args.get("agent")
+
+                # Get model_group from args
+                model_group = args.get("model_group")
+
+                # Get platform and model based on model_group (thinking mode removed)
+                from jarvis.jarvis_utils.config import (
+                    get_normal_platform_name,
+                    get_normal_model_name,
+                )
+
+                platform_name = None
+                model_name = None
+
+                # 优先根据 model_group 获取（确保配置一致性）
+                # 如果 model_group 存在，强制使用它来解析，避免使用 agent.model 中可能不一致的值
+                if model_group:
+                    platform_name = get_normal_platform_name(model_group)
+                    model_name = get_normal_model_name(model_group)
+                else:
+                    # 如果没有提供 model_group，尝试从传入的 agent 获取
+                    if (
+                        agent_from_args
+                        and hasattr(agent_from_args, "model")
+                        and getattr(agent_from_args, "model", None)
+                    ):
+                        try:
+                            platform_name = agent_from_args.model.platform_name()
+                            model_name = agent_from_args.model.name()
+                            if hasattr(agent_from_args.model, "model_group"):
+                                model_group = agent_from_args.model.model_group
+                        except Exception:
+                            # 安全回退到后续逻辑
+                            platform_name = None
+                            model_name = None
+                    
+                    # 如果仍未获取到，使用配置文件中的默认值（传入 None 会读取默认配置）
+                    if not platform_name:
+                        platform_name = get_normal_platform_name(None)
+                    if not model_name:
+                        model_name = get_normal_model_name(None)
+
+                # 最后的回退：尝试从全局 agent 获取（仅当仍未获取到时）
+                if not platform_name:
+                    agent = get_agent(current_agent_name)
+                    if (
+                        agent
+                        and hasattr(agent, "model")
+                        and getattr(agent, "model", None)
+                    ):
+                        try:
+                            platform_name = agent.model.platform_name()
+                            model_name = agent.model.name()
+                            if not model_group and hasattr(agent.model, "model_group"):
+                                model_group = agent.model.model_group
+                        except Exception:
+                            # 如果全局 agent 也无法获取，使用配置文件默认值
+                            if not platform_name:
+                                platform_name = get_normal_platform_name(None)
+                            if not model_name:
+                                model_name = get_normal_model_name(None)
+
+                # Create a new platform instance
+                if platform_name:
+                    platform = PlatformRegistry().create_platform(platform_name)
+                    if platform and model_name:
+                        platform.set_model_name(model_name)
+                    if platform and model_group:
+                        try:
+                            platform.set_model_group(model_group)
+                        except Exception:
+                            # 兼容早期实现
+                            platform.model_group = model_group  # type: ignore
+                else:
+                    platform = PlatformRegistry().get_normal_platform()
+
+                # 跳过模型可用性校验：
+                # 为避免某些平台/代理不支持 get_model_list 接口导致的噪音日志（如 404），
+                # 这里默认不调用 platform.get_model_list() 进行模型可用性校验。
+                # 如果未来需要恢复校验，可参考被移除的逻辑。
+                # no-op
+
+                # Ensure platform is not None
+                if not platform:
+                    return {
+                        "success": False,
+                        "stdout": "",
+                        "stderr": "错误：无法创建平台实例",
+                    }
+
                 upload_success = False
 
                 # Check if content is too large
-                is_large_content = is_context_overflow(diff)
+                is_large_content = is_context_overflow(diff, model_group)
 
                 if is_large_content:
                     if not platform.support_upload_files():
-                        print("❌ 差异文件太大，无法处理")
+                        PrettyOutput.print("差异文件太大，无法处理", OutputType.ERROR)
                         return {
                             "success": False,
                             "stdout": "",
                             "stderr": "错误：差异文件太大，无法处理",
                         }
-                    print("📤 正在上传代码差异文件...")
+
                     # 创建临时文件并写入差异内容
                     with tempfile.NamedTemporaryFile(
                         mode="w", suffix=".diff", delete=False
@@ -184,12 +274,12 @@ commit信息
                         temp_diff_file_path = temp_diff_file.name
                         temp_diff_file.write(diff)
                         temp_diff_file.flush()
-                        print(f"✅ 差异内容已写入临时文件")
+
                     upload_success = platform.upload_files([temp_diff_file_path])
                     if upload_success:
-                        print("✅ 成功上传代码差异文件")
+                        pass
                     else:
-                        print("❌ 上传代码差异文件失败")
+                        PrettyOutput.print("上传代码差异文件失败", OutputType.ERROR)
                         return {
                             "success": False,
                             "stdout": "",
@@ -198,7 +288,6 @@ commit信息
                 # 根据上传状态准备完整的提示
                 if is_large_content:
                     # 尝试生成提交信息
-                    print("✨ 正在生成提交消息...")
                     # 使用上传的文件
                     prompt = (
                         base_prompt
@@ -245,24 +334,42 @@ commit信息
                     {ct("COMMIT_MESSAGE")}
                     """
                     commit_message = platform.chat_until_success(prompt)
-                print("✅ 生成提交消息")
 
                 # 执行提交
-                print("⚙️ 正在准备提交...")
-                with tempfile.NamedTemporaryFile(mode="w", delete=True) as tmp_file:
+
+                # Windows 兼容性：使用 delete=False 避免权限错误
+                tmp_file = tempfile.NamedTemporaryFile(mode="w", delete=False)
+                tmp_file_path = tmp_file.name
+                try:
                     tmp_file.write(commit_message)
-                    tmp_file.flush()
-                    print("💾 正在执行提交...")
-                    commit_cmd = ["git", "commit", "-F", tmp_file.name]
-                    subprocess.Popen(
+                    tmp_file.close()  # Windows 需要先关闭文件才能被其他进程读取
+
+                    commit_cmd = ["git", "commit", "-F", tmp_file_path]
+                    process = subprocess.Popen(
                         commit_cmd,
-                        stdout=subprocess.DEVNULL,
-                        stderr=subprocess.DEVNULL,
-                    ).wait()
-                    print("✅ 提交")
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE,
+                        text=True,
+                    )
+                    stdout, stderr = process.communicate()
+
+                    if process.returncode != 0:
+                        # 如果提交失败，重置暂存区
+                        subprocess.run(["git", "reset", "HEAD"], check=False)
+                        error_msg = (
+                            stderr.strip() if stderr else "Unknown git commit error"
+                        )
+                        raise Exception(f"Git commit failed: {error_msg}")
+
+                finally:
+                    # 手动删除临时文件
+                    try:
+                        os.unlink(tmp_file_path)
+                    except Exception:
+                        pass
 
                 commit_hash = self._get_last_commit_hash()
-                print("✅ 完成提交")
+
             finally:
                 # 清理临时差异文件
                 if temp_diff_file_path is not None and os.path.exists(
@@ -271,7 +378,9 @@ commit信息
                     try:
                         os.unlink(temp_diff_file_path)
                     except Exception as e:
-                        print(f"⚠️ 无法删除临时文件: {str(e)}")
+                        PrettyOutput.print(
+                            f"无法删除临时文件: {str(e)}", OutputType.WARNING
+                        )
 
             PrettyOutput.print(
                 f"提交哈希: {commit_hash}\n提交消息: {commit_message}",
@@ -298,34 +407,41 @@ commit信息
             os.chdir(original_dir)
 
 
-def main():
-    init_env("欢迎使用 Jarvis-GitCommitTool，您的Git提交助手已准备就绪！")
-    parser = argparse.ArgumentParser(description="Git commit tool")
-    parser.add_argument(
-        "--root-dir", type=str, default=".", help="Root directory of the Git repository"
-    )
-    parser.add_argument(
+@app.command()
+def cli(
+    root_dir: str = typer.Option(".", "--root-dir", help="Git仓库的根目录路径"),
+    prefix: str = typer.Option(
+        "",
         "--prefix",
-        type=str,
-        default="",
-        help="Prefix to prepend to commit message (separated by space)",
-    )
-    parser.add_argument(
+        help="提交信息前缀（用空格分隔）",
+    ),
+    suffix: str = typer.Option(
+        "",
         "--suffix",
-        type=str,
-        default="",
-        help="Suffix to append to commit message (separated by newline)",
-    )
-    args = parser.parse_args()
+        help="提交信息后缀（用换行分隔）",
+    ),
+
+    model_group: Optional[str] = typer.Option(
+        None, "-g", "--llm-group", help="使用的模型组，覆盖配置文件中的设置"
+    ),
+):
+    init_env("欢迎使用 Jarvis-GitCommitTool，您的Git提交助手已准备就绪！")
     tool = GitCommitTool()
     tool.execute(
         {
-            "root_dir": args.root_dir,
-            "prefix": args.prefix if hasattr(args, "prefix") else "",
-            "suffix": args.suffix if hasattr(args, "suffix") else "",
+            "root_dir": root_dir,
+            "prefix": prefix,
+            "suffix": suffix,
+
+            "model_group": model_group,
         }
     )
 
 
+def main():
+    """Application entry point"""
+    app()
+
+
 if __name__ == "__main__":
-    sys.exit(main())
+    main()

jarvis/jarvis_mcp/sse_mcp_client.py

@@ -2,10 +2,10 @@
 import json
 import threading
 import time
-from typing import Any, Callable, Dict, List
+from typing import Any, Callable, Dict, List, Optional
 from urllib.parse import parse_qs, urlencode, urljoin
 
-import requests
+import requests  # type: ignore[import-untyped]
 
 from jarvis.jarvis_mcp import McpClient
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
@@ -46,13 +46,17 @@ class SSEMcpClient(McpClient):
         self.session.headers.update(extra_headers)
 
         # SSE相关属性
-        self.sse_response = None
-        self.sse_thread = None
-        self.messages_endpoint = None
-        self.session_id = None  # 从SSE连接获取的会话ID
-        self.pending_requests = {}  # 存储等待响应的请求 {id: Event}
-        self.request_results = {}  # 存储请求结果 {id: result}
-        self.notification_handlers = {}
+        self.sse_response: Optional[requests.Response] = None
+        self.sse_thread: Optional[threading.Thread] = None
+        self.messages_endpoint: Optional[str] = None
+        self.session_id: Optional[str] = None
+        self.pending_requests: Dict[str, threading.Event] = (
+            {}
+        )  # 存储等待响应的请求 {id: Event}
+        self.request_results: Dict[str, Dict[str, Any]] = (
+            {}
+        )  # 存储请求结果 {id: result}
+        self.notification_handlers: Dict[str, List[Callable]] = {}
         self.event_lock = threading.Lock()
         self.request_id_counter = 0
 
@@ -123,13 +127,15 @@ class SSEMcpClient(McpClient):
             self.sse_response = self.session.get(
                 sse_url, stream=True, headers=sse_headers, timeout=30
             )
-            self.sse_response.raise_for_status()
+            if self.sse_response:
+                self.sse_response.raise_for_status()
 
             # 启动事件处理线程
             self.sse_thread = threading.Thread(
                 target=self._process_sse_events, daemon=True
             )
-            self.sse_thread.start()
+            if self.sse_thread:
+                self.sse_thread.start()
 
         except Exception as e:
             PrettyOutput.print(f"SSE连接失败: {str(e)}", OutputType.ERROR)
@@ -204,13 +210,14 @@ class SSEMcpClient(McpClient):
 
                 # 调用已注册的处理器
                 if method in self.notification_handlers:
+                    error_lines: List[str] = []
                     for handler in self.notification_handlers[method]:
                         try:
                             handler(params)
                         except Exception as e:
-                            PrettyOutput.print(
-                                f"处理通知时出错 ({method}): {e}", OutputType.ERROR
-                            )
+                            error_lines.append(f"处理通知时出错 ({method}): {e}")
+                    if error_lines:
+                        PrettyOutput.print("\n".join(error_lines), OutputType.ERROR)
         except json.JSONDecodeError:
             PrettyOutput.print(f"无法解析SSE事件: {data}", OutputType.WARNING)
         except Exception as e:
@@ -561,7 +568,7 @@ class SSEMcpClient(McpClient):
         if self.sse_response:
             try:
                 self.sse_response.close()
-            except:
+            except Exception:
                 pass
 
         # 关闭HTTP会话

jarvis/jarvis_mcp/stdio_mcp_client.py

@@ -2,7 +2,7 @@
 import json
 import os
 import subprocess
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
 
 from jarvis.jarvis_mcp import McpClient
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
@@ -17,7 +17,7 @@ class StdioMcpClient(McpClient):
 
     def __init__(self, config: Dict[str, Any]):
         self.config = config
-        self.process = None
+        self.process: Optional[subprocess.Popen] = None
         self.protocol_version = "2025-03-26"  # MCP协议版本
         self._start_process()
         self._initialize()
@@ -73,7 +73,7 @@ class StdioMcpClient(McpClient):
                     f"初始化失败: {response.get('error', 'Unknown error')}"
                 )
 
-            result = response["result"]
+            response["result"]
 
             # 发送initialized通知 - 使用正确的方法名格式
             self._send_notification("notifications/initialized", {})
@@ -296,6 +296,6 @@ class StdioMcpClient(McpClient):
                 self._send_notification("notifications/exit", {})
                 # 等待进程结束
                 self.process.wait(timeout=1)
-            except:
+            except Exception:
                 # 如果进程没有正常退出，强制终止
                 self.process.kill()

jarvis/jarvis_mcp/streamable_mcp_client.py

@@ -4,7 +4,7 @@ import threading
 from typing import Any, Callable, Dict, List
 from urllib.parse import urljoin
 
-import requests
+import requests  # type: ignore[import-untyped]
 
 from jarvis.jarvis_mcp import McpClient
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
@@ -25,6 +25,8 @@ class StreamableMcpClient(McpClient):
         self.base_url = config.get("base_url", "")
         if not self.base_url:
             raise ValueError("No base_url specified in config")
+        # Normalize base_url to ensure trailing slash for urljoin correctness
+        self.base_url = self.base_url.rstrip("/") + "/"
 
         # 设置HTTP客户端
         self.session = requests.Session()
@@ -43,11 +45,17 @@ class StreamableMcpClient(McpClient):
         # 添加额外的HTTP头
         extra_headers = config.get("headers", {})
         self.session.headers.update(extra_headers)
+        # Request timeouts (connect, read) in seconds; can be overridden via config["timeout"]
+        self.timeout = config.get("timeout", (10, 300))
 
         # 请求相关属性
-        self.pending_requests = {}  # 存储等待响应的请求 {id: Event}
-        self.request_results = {}  # 存储请求结果 {id: result}
-        self.notification_handlers = {}
+        self.pending_requests: Dict[str, threading.Event] = (
+            {}
+        )  # 存储等待响应的请求 {id: Event}
+        self.request_results: Dict[str, Dict[str, Any]] = (
+            {}
+        )  # 存储请求结果 {id: result}
+        self.notification_handlers: Dict[str, List[Callable]] = {}
         self.event_lock = threading.Lock()
         self.request_id_counter = 0
 
@@ -144,37 +152,46 @@ class StreamableMcpClient(McpClient):
             # 发送请求到Streamable HTTP端点
             mcp_url = urljoin(self.base_url, "mcp")
             response = self.session.post(
-                mcp_url, json=request, stream=True  # 启用流式传输
-            )
+                mcp_url, json=request, stream=True, timeout=self.timeout
+            )  # 启用流式传输
             response.raise_for_status()
 
             # 处理流式响应
             result = None
+            warning_lines = []
+            error_lines = []
             for line in response.iter_lines(decode_unicode=True):
                 if line:
                     try:
-                        data = json.loads(line)
+                        line_data = line
+                        if isinstance(line_data, str) and line_data.startswith("data:"):
+                            # Handle SSE-formatted lines like "data: {...}"
+                            line_data = line_data.split(":", 1)[1].strip()
+                        data = json.loads(line_data)
                         if "id" in data and data["id"] == req_id:
                             # 这是我们的请求响应
                             result = data
                             break
                         elif "method" in data:
                             # 这是一个通知
-                            method = data.get("method", "")
+                            notify_method = data.get("method", "")
                             params = data.get("params", {})
-                            if method in self.notification_handlers:
-                                for handler in self.notification_handlers[method]:
+                            if notify_method in self.notification_handlers:
+                                for handler in self.notification_handlers[notify_method]:
                                     try:
                                         handler(params)
                                     except Exception as e:
-                                        PrettyOutput.print(
-                                            f"处理通知时出错 ({method}): {e}",
-                                            OutputType.ERROR,
-                                        )
+                                        error_lines.append(f"处理通知时出错 ({notify_method}): {e}")
                     except json.JSONDecodeError:
-                        PrettyOutput.print(f"无法解析响应: {line}", OutputType.WARNING)
+                        warning_lines.append(f"无法解析响应: {line}")
                         continue
 
+            if warning_lines:
+                PrettyOutput.print("\n".join(warning_lines), OutputType.WARNING)
+            if error_lines:
+                PrettyOutput.print("\n".join(error_lines), OutputType.ERROR)
+            # Ensure response is closed after streaming
+            response.close()
             if result is None:
                 raise RuntimeError(f"未收到响应: {method}")
 
@@ -202,8 +219,11 @@ class StreamableMcpClient(McpClient):
 
             # 发送通知到Streamable HTTP端点
             mcp_url = urljoin(self.base_url, "mcp")
-            response = self.session.post(mcp_url, json=notification)
+            response = self.session.post(
+                mcp_url, json=notification, timeout=self.timeout
+            )
             response.raise_for_status()
+            response.close()
 
         except Exception as e:
             PrettyOutput.print(f"发送通知失败: {str(e)}", OutputType.ERROR)