jarvis-ai-assistant 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

jarvis/jarvis_git_details/main.py

@@ -1,265 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Git Commit分析工具模块
-
-该模块提供了一个GitCommitAnalyzer类，用于获取和分析指定Git commit的详细信息，
-包括提交信息、修改内容以及详细的功能、原因和逻辑分析。
-"""
-
-import os
-import re
-import subprocess
-from typing import Any, Dict
-
-from jarvis.jarvis_agent import Agent
-from jarvis.jarvis_platform.registry import PlatformRegistry
-from jarvis.jarvis_tools.registry import ToolRegistry
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
-from jarvis.jarvis_utils.tag import ct, ot
-from jarvis.jarvis_utils.utils import init_env
-
-
-class GitCommitAnalyzer:
-    """Git Commit分析器
-
-    该类用于获取和分析指定Git commit的详细信息，包括：
-    - 完整的提交信息
-    - 修改的文件列表和状态
-    - 修改的功能、原因和逻辑分析
-    """
-
-    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
-        """执行commit分析
-
-        Args:
-            args: 包含commit_sha/commit_range和root_dir的参数字典
-                commit_sha: 单个commit的SHA
-                commit_range: 两个commit的SHA范围，格式为"commit1..commit2"
-                root_dir: 代码库根目录
-
-        Returns:
-            包含分析结果的字典
-        """
-        try:
-            commit_sha = args.get("commit_sha")
-            commit_range = args.get("commit_range")
-            root_dir = args.get("root_dir", ".")
-
-            if commit_range:
-                return self.analyze_commit_range(commit_range, root_dir)
-            elif commit_sha:
-                return self.analyze_single_commit(commit_sha, root_dir)
-            else:
-                raise ValueError("Either commit_sha or commit_range must be provided")
-        except Exception as e:
-            return {
-                "success": False,
-                "stdout": {},
-                "stderr": f"Failed to analyze commit: {str(e)}",
-            }
-
-    def analyze_single_commit(self, commit_sha: str, root_dir: str) -> Dict[str, Any]:
-        """分析单个commit
-
-        Args:
-            commit_sha: commit的SHA
-            root_dir: 代码库根目录
-
-        Returns:
-            包含分析结果的字典
-        """
-        original_dir = os.getcwd()
-        try:
-            os.chdir(root_dir)
-
-            # 获取commit详细信息
-            commit_info = subprocess.check_output(
-                f"git show {commit_sha} --pretty=fuller", shell=True, text=True
-            )
-
-            # 获取commit修改内容
-            diff_content = subprocess.check_output(
-                f"git show {commit_sha} --patch", shell=True, text=True
-            )
-
-            # 分析commit的功能、原因和逻辑
-            analysis_result = self._analyze_diff_content(diff_content)
-
-            return {
-                "success": True,
-                "stdout": {
-                    "commit_info": commit_info,
-                    "diff_content": diff_content,
-                    "analysis_result": analysis_result,
-                },
-                "stderr": "",
-            }
-        except subprocess.CalledProcessError as error:
-            return {
-                "success": False,
-                "stdout": {},
-                "stderr": f"Failed to analyze commit: {str(error)}",
-            }
-        finally:
-            os.chdir(original_dir)
-
-    def analyze_commit_range(self, commit_range: str, root_dir: str) -> Dict[str, Any]:
-        """分析两个commit之间的代码变更
-
-        Args:
-            commit_range: 两个commit的SHA范围，格式为"commit1..commit2"
-            root_dir: 代码库根目录
-
-        Returns:
-            包含分析结果的字典
-        """
-        original_dir = os.getcwd()
-        try:
-            os.chdir(root_dir)
-
-            # 获取commit范围差异
-            diff_content = subprocess.check_output(
-                f"git diff {commit_range} --patch", shell=True, text=True
-            )
-
-            # 获取commit范围信息
-            commit_info = subprocess.check_output(
-                f"git log {commit_range} --pretty=fuller", shell=True, text=True
-            )
-
-            # 使用相同的分析方法处理差异内容
-            analysis_result = self._analyze_diff_content(diff_content)
-
-            return {
-                "success": True,
-                "stdout": {
-                    "commit_info": commit_info,
-                    "diff_content": diff_content,
-                    "analysis_result": analysis_result,
-                },
-                "stderr": "",
-            }
-        except subprocess.CalledProcessError as error:
-            return {
-                "success": False,
-                "stdout": {},
-                "stderr": f"Failed to analyze commit range: {str(error)}",
-            }
-        finally:
-            os.chdir(original_dir)
-
-    def _analyze_diff_content(self, diff_content: str) -> str:
-        """分析diff内容并生成报告
-
-        Args:
-            diff_content: git diff或git show的输出内容
-
-        Returns:
-            分析结果字符串
-        """
-        system_prompt = """你是一位资深代码分析专家，拥有多年代码审查和重构经验。你需要对Git commit进行深入分析，包括：
-1. 修改的功能：明确说明本次commit实现或修改了哪些功能
-2. 修改的原因：分析为什么要进行这些修改（如修复bug、优化性能、添加新功能等）
-3. 修改的逻辑：详细说明代码修改的具体实现逻辑和思路
-4. 影响范围：评估本次修改可能影响的其他模块或功能
-5. 代码质量：分析代码风格、可读性和可维护性
-6. 测试覆盖：评估是否需要添加或修改测试用例
-7. 最佳实践：检查代码是否符合行业最佳实践和项目规范
-
-请确保分析内容：
-- 准确反映commit的实际修改
-- 提供足够的技术细节
-- 保持结构清晰，便于理解
-- 重点关注关键修改和潜在风险"""
-
-        tool_registry = ToolRegistry()
-        agent = Agent(
-            system_prompt=system_prompt,
-            name="Commit Analysis Agent",
-            summary_prompt=f"""请生成一份详细的commit分析报告，包含以下内容：
-{ot("REPORT")}
-# 功能分析
-[说明本次commit实现或修改了哪些功能]
-
-# 修改原因
-[分析进行这些修改的原因，如修复bug、优化性能、添加新功能等]
-
-# 实现逻辑
-[详细说明代码修改的具体实现逻辑和思路]
-
-# 影响范围
-[评估本次修改可能影响的其他模块或功能]
-
-# 代码质量
-[分析代码风格、可读性和可维护性]
-
-# 测试覆盖
-[评估是否需要添加或修改测试用例]
-
-# 最佳实践
-[检查代码是否符合行业最佳实践和项目规范]
-{ct("REPORT")}""",
-            output_handler=[tool_registry],
-            llm_type="normal",
-            auto_complete=True,
-        )
-
-        return agent.run(diff_content)
-
-
-def extract_analysis_report(result: str) -> str:
-    """从分析结果中提取报告内容
-
-    Args:
-        result: 包含REPORT标签的完整分析结果字符串
-
-    Returns:
-        提取的报告内容，如果未找到REPORT标签则返回空字符串
-    """
-    search_match = re.search(
-        ot("REPORT") + r"\n(.*?)\n" + ct("REPORT"), result, re.DOTALL
-    )
-    if search_match:
-        return search_match.group(1)
-    return result
-
-
-def main():
-    """主函数，用于命令行接口"""
-    import argparse
-
-    init_env("欢迎使用 Jarvis-GitCommitAnalyzer，您的Git Commit分析助手已准备就绪！")
-
-    parser = argparse.ArgumentParser(description="Git Commit Analyzer")
-    group = parser.add_mutually_exclusive_group(required=True)
-    group.add_argument("commit", nargs="?", help="Commit SHA to analyze")
-    group.add_argument(
-        "--range", type=str, help="Commit range to analyze (commit1..commit2)"
-    )
-    parser.add_argument(
-        "--root-dir", type=str, help="Root directory of the codebase", default="."
-    )
-
-    args = parser.parse_args()
-
-    analyzer = GitCommitAnalyzer()
-    if args.range:
-        result = analyzer.execute(
-            {"commit_range": args.range, "root_dir": args.root_dir}
-        )
-    else:
-        result = analyzer.execute(
-            {"commit_sha": args.commit, "root_dir": args.root_dir}
-        )
-
-    if result["success"]:
-        PrettyOutput.section("Commit Information:", OutputType.SUCCESS)
-        PrettyOutput.print(result["stdout"]["commit_info"], OutputType.CODE)
-        PrettyOutput.section("Analysis Report:", OutputType.SUCCESS)
-        report = extract_analysis_report(result["stdout"]["analysis_result"])
-        PrettyOutput.print(report, OutputType.SUCCESS, lang="markdown")
-    else:
-        PrettyOutput.print(result["stderr"], OutputType.WARNING)
-
-
-if __name__ == "__main__":
-    main()

jarvis/jarvis_platform/oyi.py

@@ -1,357 +0,0 @@
-import mimetypes
-import os
-from typing import Dict, Generator, List, Tuple
-from jarvis.jarvis_platform.base import BasePlatform
-import json
-
-from jarvis.jarvis_utils import http
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
-from jarvis.jarvis_utils.utils import while_success
-
-
-class OyiModel(BasePlatform):
-    """Oyi model implementation"""
-
-    BASE_URL = "https://api-10086.rcouyi.com"
-
-    def get_model_list(self) -> List[Tuple[str, str]]:
-        """Get model list"""
-        self.get_available_models()
-        return [(name, info["desc"]) for name, info in self.models.items()]
-
-    def __init__(self):
-        """Initialize model"""
-        super().__init__()
-        self.models = {}
-        self.messages = []
-        self.system_prompt = ""
-        self.conversation = None
-        self.first_chat = True
-
-        self.token = os.getenv("OYI_API_KEY")
-        if not self.token:
-            PrettyOutput.print("OYI_API_KEY 未设置", OutputType.WARNING)
-
-        self.model_name = os.getenv("JARVIS_MODEL") or "deepseek-chat"
-        if self.model_name not in [m.split()[0] for m in self.get_available_models()]:
-            PrettyOutput.print(
-                f"警告: 选择的模型 {self.model_name} 不在可用列表中", OutputType.WARNING
-            )
-
-    def set_model_name(self, model_name: str):
-        """Set model name"""
-
-        self.model_name = model_name
-
-    def create_conversation(self) -> bool:
-        """Create a new conversation"""
-        try:
-            headers = {
-                "Authorization": f"Bearer {self.token}",
-                "Content-Type": "application/json",
-                "Accept": "application/json",
-                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
-            }
-
-            payload = {
-                "id": 0,
-                "roleId": 0,
-                "title": "New conversation",
-                "isLock": False,
-                "systemMessage": "",
-                "params": json.dumps(
-                    {
-                        "model": self.model_name,
-                        "is_webSearch": True,
-                        "message": [],
-                        "systemMessage": None,
-                        "requestMsgCount": 65536,
-                        "temperature": 0.8,
-                        "speechVoice": "Alloy",
-                        "max_tokens": 8192,
-                        "chatPluginIds": [],
-                    }
-                ),
-            }
-
-            response = while_success(
-                lambda: http.post(
-                    f"{self.BASE_URL}/chatapi/chat/save", headers=headers, json=payload
-                ),
-                sleep_time=5,
-            )
-
-            data = response.json()
-            if data["code"] == 200 and data["type"] == "success":
-                self.conversation = data
-                return True
-            else:
-                PrettyOutput.print(
-                    f"创建会话失败: {data['message']}", OutputType.WARNING
-                )
-                return False
-
-        except Exception as e:
-            PrettyOutput.print(f"创建会话失败: {str(e)}", OutputType.ERROR)
-            return False
-
-    def set_system_prompt(self, message: str):
-        """Set system message"""
-        self.system_prompt = message
-
-    def chat(self, message: str) -> Generator[str, None, None]:
-        """Execute chat with the model
-
-        Args:
-            message: User input message
-
-        Returns:
-            str: Model response
-        """
-        try:
-            # 确保有会话ID
-            if not self.conversation:
-                if not self.create_conversation():
-                    raise Exception("Failed to create conversation")
-
-            # 1. 发送消息
-            headers = {
-                "Authorization": f"Bearer {self.token}",
-                "Content-Type": "application/json",
-                "Accept": "application/json, text/plain, */*",
-                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
-                "Origin": "https://ai.rcouyi.com",
-                "Referer": "https://ai.rcouyi.com/",
-            }
-
-            payload = {
-                "topicId": (
-                    self.conversation["result"]["id"] if self.conversation else None
-                ),
-                "messages": self.messages,
-                "content": message,
-                "contentFiles": [],
-            }
-
-            # 如果有上传的文件，添加到请求中
-            if self.first_chat:
-                message = self.system_prompt + "\n" + message
-                payload["content"] = message
-                self.first_chat = False
-
-            self.messages.append({"role": "user", "content": message})
-
-            # 发送消息
-            response = while_success(
-                lambda: http.post(
-                    f"{self.BASE_URL}/chatapi/chat/message",
-                    headers=headers,
-                    json=payload,
-                ),
-                sleep_time=5,
-            )
-
-            data = response.json()
-            if data["code"] != 200 or data["type"] != "success":
-                error_msg = f"聊天失败: {data.get('message', '未知错误')}"
-                PrettyOutput.print(error_msg, OutputType.WARNING)
-                raise Exception(error_msg)
-
-            message_id = data["result"][-1]
-
-            # 获取响应内容
-            response = while_success(
-                lambda: http.stream_post(
-                    f"{self.BASE_URL}/chatapi/chat/message/{message_id}",
-                    headers=headers,
-                ),
-                sleep_time=5,
-            )
-
-            full_response = ""
-            bin = b""
-            for chunk in response:
-                if chunk:
-                    bin += chunk
-                    try:
-                        text = bin.decode("utf-8")
-                    except UnicodeDecodeError:
-                        continue
-                    full_response += text
-                    bin = b""
-                    yield text
-
-            self.messages.append({"role": "assistant", "content": full_response})
-            return None
-        except Exception as e:
-            PrettyOutput.print(f"聊天失败: {str(e)}", OutputType.ERROR)
-            raise e
-
-    def name(self) -> str:
-        """Return model name"""
-        return self.model_name
-
-    @classmethod
-    def platform_name(cls) -> str:
-        """Return platform name"""
-        return "oyi"
-
-    def delete_chat(self) -> bool:
-        """Delete current chat session"""
-        try:
-            if not self.conversation:
-                return True
-
-            headers = {
-                "Authorization": f"Bearer {self.token}",
-                "Content-Type": "application/json",
-                "Accept": "application/json, text/plain, */*",
-                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
-                "Origin": "https://ai.rcouyi.com",
-                "Referer": "https://ai.rcouyi.com/",
-            }
-
-            response = while_success(
-                lambda: http.post(
-                    f"{self.BASE_URL}/chatapi/chat/{self.conversation['result']['id']}",  # type: ignore
-                    headers=headers,
-                    json={},
-                ),
-                sleep_time=5,
-            )
-
-            data = response.json()
-            if data["code"] == 200 and data["type"] == "success":
-                self.messages = []
-                self.conversation = None
-                self.first_chat = True
-                return True
-            else:
-                error_msg = f"删除会话失败: {data.get('message', '未知错误')}"
-                PrettyOutput.print(error_msg, OutputType.WARNING)
-                return False
-
-        except Exception as e:
-            PrettyOutput.print(f"删除会话失败: {str(e)}", OutputType.ERROR)
-            return False
-
-    def save(self, file_path: str) -> bool:
-        """Save chat session to a file."""
-        if not self.conversation:
-            PrettyOutput.print("没有活动的会话可供保存", OutputType.WARNING)
-            return False
-
-        state = {
-            "conversation": self.conversation,
-            "messages": self.messages,
-            "model_name": self.model_name,
-            "system_prompt": self.system_prompt,
-            "first_chat": self.first_chat,
-        }
-
-        try:
-            with open(file_path, "w", encoding="utf-8") as f:
-                json.dump(state, f, ensure_ascii=False, indent=4)
-            self._saved = True
-            PrettyOutput.print(f"会话已成功保存到 {file_path}", OutputType.SUCCESS)
-            return True
-        except Exception as e:
-            PrettyOutput.print(f"保存会话失败: {str(e)}", OutputType.ERROR)
-            return False
-
-    def restore(self, file_path: str) -> bool:
-        """Restore chat session from a file."""
-        try:
-            with open(file_path, "r", encoding="utf-8") as f:
-                state = json.load(f)
-
-            self.conversation = state.get("conversation")
-            self.messages = state.get("messages", [])
-            self.model_name = state.get("model_name", "deepseek-chat")
-            self.system_prompt = state.get("system_prompt", "")
-            self.first_chat = state.get("first_chat", True)
-            self._saved = True
-
-            PrettyOutput.print(f"从 {file_path} 成功恢复会话", OutputType.SUCCESS)
-            return True
-        except FileNotFoundError:
-            PrettyOutput.print(f"会话文件未找到: {file_path}", OutputType.ERROR)
-            return False
-        except Exception as e:
-            PrettyOutput.print(f"恢复会话失败: {str(e)}", OutputType.ERROR)
-            return False
-
-    def get_available_models(self) -> List[str]:
-        """Get available model list
-
-        Returns:
-            List[str]: Available model name list
-        """
-        try:
-            if self.models:
-                return list(self.models.keys())
-
-            headers = {
-                "Content-Type": "application/json",
-                "Accept": "application/json, text/plain, */*",
-                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
-                "Origin": "https://ai.rcouyi.com",
-                "Referer": "https://ai.rcouyi.com/",
-            }
-
-            response = while_success(
-                lambda: http.get(
-                    "https://ai.rcouyi.com/config/system.json", headers=headers
-                ),
-                sleep_time=5,
-            )
-
-            data = response.json()
-
-            # 保存模型信息
-            self.models = {
-                model["value"]: model
-                for model in data.get("model", [])
-                if model.get("enable", False)  # 只保存启用的模型
-            }
-
-            # 格式化显示
-            models = []
-            for model in self.models.values():
-                # 基本信息
-                model_name = model["value"]
-                model_str = model["label"]
-
-                # 添加后缀标签
-                suffix = model.get("suffix", [])
-                if suffix:
-                    # 处理新格式的suffix (字典列表)
-                    if suffix and isinstance(suffix[0], dict):
-                        suffix_str = ", ".join(s.get("tag", "") for s in suffix)
-                    # 处理旧格式的suffix (字符串列表)
-                    else:
-                        suffix_str = ", ".join(str(s) for s in suffix)
-                    model_str += f" ({suffix_str})"
-
-                # 添加描述或提示
-                info = model.get("tooltip") or model.get("description", "")
-                if info:
-                    model_str += f" - {info}"
-
-                model["desc"] = model_str
-                models.append(model_name)
-
-            return sorted(models)
-
-        except Exception as e:
-            PrettyOutput.print(f"获取模型列表失败: {str(e)}", OutputType.WARNING)
-            return []
-
-    def support_upload_files(self) -> bool:
-        return False
-
-    def support_web(self) -> bool:
-        return False
-
-    def upload_files(self, file_list: List[str]) -> bool:
-        return False