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

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

jarvis/jarvis_tools/edit_file.py

@@ -1,255 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-文件编辑工具类
-
-功能概述:
-1. 提供精确的文件内容搜索和替换功能，支持多组修改
-2. 支持单个文件的编辑操作，包括创建新文件
-3. 实现原子操作：所有修改要么全部成功，要么全部回滚
-4. 严格匹配控制：每个搜索文本必须且只能匹配一次
-
-核心特性:
-- 支持不存在的文件和空文件处理
-- 自动创建所需目录结构
-- 完善的错误处理和回滚机制
-- 严格的格式保持要求
-"""
-from typing import Any, Dict
-
-from jarvis.jarvis_agent.edit_file_handler import EditFileHandler
-
-
-class FileSearchReplaceTool:
-    name = "edit_file"
-    description = """代码编辑工具，用于精确修改一个或多个文件
-
-# 文件编辑工具使用指南
-
-## 基本使用
-1. 指定需要修改的文件路径（单个或多个）
-2. 提供一组或多组修改，每个修改包含:
-   - reason: 修改原因描述
-   - SEARCH: 需要查找的原始代码(必须包含足够上下文)
-   - REPLACE: 替换后的新代码
-3. 工具会自动选择最适合的编辑模式
-
-## 核心原则
-1. **精准修改**: 只修改必要的代码部分，保持其他部分不变
-2. **最小补丁原则**: 生成最小范围的补丁，包含必要的上下文
-3. **唯一匹配**: 确保搜索文本在文件中唯一匹配
-4. **格式保持**: 严格保持原始代码的格式风格
-5. **部分成功**: 支持多个文件编辑，允许部分文件编辑成功
-
-"""
-    parameters = {
-        "type": "object",
-        "properties": {
-            "files": {
-                "type": "array",
-                "description": "需要修改的文件路径列表",
-                "items": {
-                    "type": "object",
-                    "properties": {
-                        "path": {"type": "string", "description": "文件路径"},
-                        "changes": {
-                            "type": "array",
-                            "description": "一组或多组修改，每个修改必须包含1-2行上下文用于精确定位",
-                            "items": {
-                                "type": "object",
-                                "properties": {
-                                    "reason": {
-                                        "type": "string",
-                                        "description": "修改的原因",
-                                    },
-                                    "SEARCH": {
-                                        "type": "string",
-                                        "description": "需要查找的原始代码",
-                                    },
-                                    "REPLACE": {
-                                        "type": "string",
-                                        "description": "替换后的新代码",
-                                    },
-                                },
-                            },
-                        },
-                    },
-                    "required": ["path", "changes"],
-                },
-            },
-        },
-        "required": ["files"],
-    }
-
-    def execute(self, args: Dict) -> Dict[str, Any]:
-        """执行文件编辑操作，支持快速编辑和AI辅助编辑两种模式。
-
-        主要功能:
-        1. 处理多个文件的创建或修改，支持不存在的文件
-        2. 每个文件独立处理，允许部分文件编辑成功
-        3. 自动选择编辑模式(fast_edit或slow_edit)
-        4. 保存修改前后的文件状态以便回滚
-        5. 提供详细的执行状态输出
-
-        参数:
-            args: 包含以下键的字典:
-                - files: 文件列表，每个文件包含(必填):
-                    - path: 要修改的文件路径
-                    - changes: 修改列表，每个修改包含:
-                        - reason: 修改原因描述
-                        - SEARCH: 需要查找的原始代码(必须包含足够上下文)
-                        - REPLACE: 替换后的新代码
-
-        返回:
-            Dict[str, Any] 包含:
-                - success: 是否至少有一个文件编辑成功(True/False)
-                - stdout: 成功时的输出消息
-                - stderr: 失败时的错误消息
-                - results: 每个文件的处理结果列表
-
-        异常处理:
-        1. 捕获并记录文件操作异常
-        2. 失败的修改尝试回滚到原始状态
-        3. 新创建的文件在失败时会被删除
-        4. 提供3次重试机制确保操作可靠性
-        5. 支持大文件处理(自动上传到模型平台)
-
-        实现细节:
-        1. 优先尝试fast_edit模式
-        2. 如果fast_edit失败，则尝试slow_edit模式
-        3. 严格检查搜索文本的唯一匹配性
-        4. 保持原始代码的格式风格
-        """
-        import os
-
-        from jarvis.jarvis_utils.output import OutputType, PrettyOutput
-
-        stdout_messages = []
-        stderr_messages = []
-        overall_success = False
-        file_results = []
-
-        for file_info in args["files"]:
-            file_path = os.path.abspath(file_info["path"])
-            changes = file_info["changes"]
-
-            # 创建已处理文件变量，用于失败时回滚
-            original_content = None
-            processed = False
-            file_success = True
-
-            try:
-                file_exists = os.path.exists(file_path)
-                content = ""
-
-                try:
-                    # 如果文件存在，则读取内容
-                    if file_exists:
-                        with open(file_path, "r", encoding="utf-8") as f:
-                            content = f.read()
-                            original_content = content
-
-                    print(f"⚙️ 正在处理文件 {file_path}...")
-                    success, temp_content = EditFileHandler._fast_edit(
-                        file_path, changes
-                    )
-                    if not success:
-                        print(f"❌ 文件 {file_path} 处理失败")
-                        file_results.append(
-                            {
-                                "file": file_path,
-                                "success": False,
-                                "stdout": "",
-                                "stderr": temp_content,
-                            }
-                        )
-                        continue
-
-                    print(f"✅ 文件 {file_path} 内容生成完成")
-
-                    # 只有当所有替换操作都成功时，才写回文件
-                    if success and (
-                        temp_content != original_content or not file_exists
-                    ):
-                        # 确保目录存在
-                        os.makedirs(
-                            os.path.dirname(os.path.abspath(file_path)), exist_ok=True
-                        )
-
-                        with open(file_path, "w", encoding="utf-8") as f:
-                            f.write(temp_content)
-
-                        processed = True
-
-                        action = "创建并写入" if not file_exists else "成功修改"
-                        stdout_message = f"文件 {file_path} {action} 完成"
-                        stdout_messages.append(stdout_message)
-                        PrettyOutput.print(stdout_message, OutputType.SUCCESS)
-                        overall_success = True
-
-                        file_results.append(
-                            {
-                                "file": file_path,
-                                "success": True,
-                                "stdout": stdout_message,
-                                "stderr": "",
-                            }
-                        )
-
-                except Exception as e:
-                    stderr_message = f"处理文件 {file_path} 时出错: {str(e)}"
-                    stderr_messages.append(stderr_message)
-                    PrettyOutput.print(stderr_message, OutputType.WARNING)
-                    file_success = False
-                    file_results.append(
-                        {
-                            "file": file_path,
-                            "success": False,
-                            "stdout": "",
-                            "stderr": stderr_message,
-                        }
-                    )
-
-            except Exception as e:
-                error_msg = f"文件搜索替换操作失败: {str(e)}"
-                PrettyOutput.print(error_msg, OutputType.WARNING)
-
-                # 如果有已修改的文件，尝试回滚
-                if processed:
-                    rollback_message = "操作失败，正在回滚修改..."
-                    stderr_messages.append(rollback_message)
-                    PrettyOutput.print(rollback_message, OutputType.WARNING)
-
-                    try:
-                        if original_content is None:
-                            # 如果是新创建的文件，则删除
-                            if os.path.exists(file_path):
-                                os.remove(file_path)
-                            stderr_messages.append(f"已删除新创建的文件: {file_path}")
-                        else:
-                            # 如果是修改的文件，则恢复原内容
-                            with open(file_path, "w", encoding="utf-8") as f:
-                                f.write(original_content)
-                            stderr_messages.append(f"已回滚文件: {file_path}")
-                    except:
-                        stderr_messages.append(f"回滚文件失败: {file_path}")
-
-                file_results.append(
-                    {
-                        "file": file_path,
-                        "success": False,
-                        "stdout": "",
-                        "stderr": error_msg,
-                    }
-                )
-
-        # 整合所有错误信息到stderr
-        all_stderr = []
-        for result in file_results:
-            if not result["success"]:
-                all_stderr.append(f"文件 {result['file']} 处理失败: {result['stderr']}")
-
-        return {
-            "success": overall_success,
-            "stdout": "\n".join(stdout_messages) if overall_success else "",
-            "stderr": "\n".join(all_stderr) if not overall_success else "",
-        }