jarvis-ai-assistant 0.1.131__py3-none-any.whl → 0.1.132__py3-none-any.whl

jarvis/jarvis_git_squash/main.py

@@ -1,3 +1,4 @@
+import re
 import sys
 import argparse
 from typing import Dict, Any
@@ -26,39 +27,23 @@ class GitSquashTool:
         except Exception:
             return False
     
-    def execute(self, args: Dict) -> Dict[str, Any]:
+    def execute(self, args: Dict):
         """Execute the squash operation"""
         try:
             if not self._confirm_squash():
-                return {
-                    "success": False,
-                    "stdout": "Operation cancelled",
-                    "stderr": ""
-                }
+                PrettyOutput.print("操作已取消", OutputType.WARNING)
+                return
             
             if not self._reset_to_commit(args['commit_hash']):
-                return {
-                    "success": False,
-                    "stdout": "",
-                    "stderr": "Failed to reset to specified commit"
-                }
+                PrettyOutput.print("重置到指定提交失败", OutputType.WARNING)
+                return
             
             # Use existing GitCommitTool for new commit
             commit_tool = GitCommitTool()
-            result = commit_tool.execute({"lang": args.get('lang', 'Chinese')})
-            
-            return {
-                "success": result['success'],
-                "stdout": result['stdout'],
-                "stderr": result['stderr']
-            }
-            
+            commit_tool.execute({"lang": args.get('lang', 'Chinese')})
         except Exception as e:
-            return {
-                "success": False,
-                "stdout": "",
-                "stderr": f"Squash failed: {str(e)}"
-            }
+            PrettyOutput.print(f"压缩提交失败: {str(e)}", OutputType.WARNING)
+            
 def main():
     init_env()
     parser = argparse.ArgumentParser(description='Git squash tool')
@@ -67,15 +52,9 @@ def main():
     args = parser.parse_args()
     
     tool = GitSquashTool()
-    result = tool.execute({
+    tool.execute({
         'commit_hash': args.commit_hash,
         'lang': args.lang
     })
-    
-    if not result['success']:
-        PrettyOutput.print(result['stderr'], OutputType.ERROR)
-        sys.exit(1)
-        
-    PrettyOutput.print(result['stdout'], OutputType.SUCCESS)
 if __name__ == "__main__":
     sys.exit(main())

jarvis/jarvis_multi_agent/__init__.py

@@ -8,7 +8,7 @@ from jarvis.jarvis_agent.output_handler import OutputHandler
 from jarvis.jarvis_tools.registry import ToolRegistry
 from jarvis.jarvis_utils.input import get_multiline_input
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
-from jarvis.jarvis_utils.utils import init_env
+from jarvis.jarvis_utils.utils import ct, ot, init_env
 
 
 class MultiAgent(OutputHandler):
@@ -20,12 +20,7 @@ class MultiAgent(OutputHandler):
 
     def prompt(self) -> str:
         return f"""
-# 多智能体协作系统
-
-## 身份与角色定位
-- **核心职责**：作为多智能体系统的协调者，通过结构化消息实现高效协作
-- **关键能力**：消息路由、任务分发、结果整合、流程协调
-- **工作范围**：在多个专业智能体之间建立有效沟通渠道
+# 多智能体消息发送
 
 ## 交互原则与策略
 ### 消息处理规范
@@ -36,7 +31,7 @@ class MultiAgent(OutputHandler):
 
 ### 消息格式标准
 ```
-<SEND_MESSAGE>
+{ot("SEND_MESSAGE")}
 to: 智能体名称    # 目标智能体名称
 content: |
     # 消息主题
@@ -52,31 +47,27 @@ content: |
     
     ## 期望结果
     [描述期望的输出格式和内容]
-</SEND_MESSAGE>
+
+    ## 下一步计划
+    [描述下一步的计划和行动]
+{ct("SEND_MESSAGE")}
 ```
 
-## 协作流程规范
-### 任务分发流程
-1. **需求分析**：理解用户需求并确定最适合的智能体
-2. **任务分解**：将复杂任务分解为可管理的子任务
-3. **精准分发**：根据专长将任务分配给合适的智能体
-4. **结果整合**：收集各智能体的输出并整合为连贯结果
+或者：
 
-### 消息流控制
-1. **单向流动**：发送消息后等待响应，避免消息风暴
-2. **优先级管理**：处理紧急消息优先，保持任务顺序
-3. **状态跟踪**：记录每个任务的当前状态和处理进度
-4. **异常处理**：优雅处理超时、错误和意外响应
+```
+{ot("SEND_MESSAGE")}
+to: 智能体名称    # 目标智能体名称
+content: |
+    # 消息主题
+    
+    ## 任务结果
+    [任务完成结果，用于反馈]
+{ct("SEND_MESSAGE")}
+```
 
 ## 可用智能体资源
 {chr(10).join([f"- **{c['name']}**: {c.get('description', '')}" for c in self.agents_config])}
-
-## 最佳实践指南
-1. **任务明确化**：每个消息专注于单一、明确的任务
-2. **信息充分性**：提供足够信息让接收者能独立完成任务
-3. **反馈循环**：建立清晰的反馈机制，及时调整方向
-4. **知识共享**：确保关键信息在相关智能体间共享
-5. **协作效率**：避免不必要的消息传递，减少协调开销
 """
 
     def can_handle(self, response: str) -> bool:
@@ -102,7 +93,7 @@ content: |
         Args:
             content: The content containing send message
         """
-        data = re.findall(r'<SEND_MESSAGE>(.*?)</SEND_MESSAGE>', content, re.DOTALL)
+        data = re.findall(ot("SEND_MESSAGE")+r'\n(.*?)\n'+ct("SEND_MESSAGE"), content, re.DOTALL)
         ret = []
         for item in data:
             try:

jarvis/jarvis_platform/ai8.py

@@ -23,7 +23,6 @@ class AI8Model(BasePlatform):
         super().__init__()
         self.system_message = ""
         self.conversation = {}
-        self.files = []
         self.models = {}  # 存储模型信息
 
         self.token = os.getenv("AI8_API_KEY")
@@ -103,18 +102,6 @@ class AI8Model(BasePlatform):
         except Exception as e:
             PrettyOutput.print(f"创建会话失败: {str(e)}", OutputType.ERROR)
             return False
-        
-    def upload_files(self, file_list: List[str]) -> List[Dict]:
-        for file_path in file_list:
-            name = os.path.basename(file_path)
-            with open(file_path, 'rb') as f:
-                file_data = f.read()
-            base64_data = base64.b64encode(file_data).decode('utf-8')
-            self.files.append({
-                "name": name,
-                "data": f"data:image/png;base64,{base64_data}"
-            })
-        return self.files
     
     def set_system_message(self, message: str):
         """Set system message"""
@@ -145,14 +132,6 @@ class AI8Model(BasePlatform):
                 "files": []
             }
             
-            # 如果有文件需要发送
-            if self.files:
-                for file_data in self.files:
-                    payload["files"].append({
-                        "name": file_data["name"],
-                        "data": file_data["data"]
-                    })
-                self.files = []  # 清空已使用的文件
             
             response = requests.post(
                 f"{self.BASE_URL}/api/chat/completions",
@@ -200,7 +179,6 @@ class AI8Model(BasePlatform):
     def reset(self):
         """Reset model state"""
         self.conversation = None
-        self.files = []  # 清空文件列表
             
     def delete_chat(self) -> bool:
         """Delete current chat session"""
@@ -284,13 +262,6 @@ class AI8Model(BasePlatform):
                 # 添加标签
                 model_str = f"{model['label']}"
                 
-                # 添加标签和积分信息
-                attrs = []
-                if model['attr'].get('tag'):
-                    attrs.append(model['attr']['tag'])
-                if model['attr'].get('integral'):
-                    attrs.append(model['attr']['integral'])
-                    
                 # 添加特性标记
                 features = []
                 if model['attr'].get('multimodal'):
@@ -299,12 +270,16 @@ class AI8Model(BasePlatform):
                     features.append("Plugin support")
                 if model['attr'].get('onlyImg'):
                     features.append("Image support")
-                if features:
-                    model_str += f" [{'|'.join(features)}]"
-                    
+                if model['attr'].get('tag'):
+                    features.append(model['attr']['tag'])
+                if model['attr'].get('integral'):
+                    features.append(model['attr']['integral'])
                 # 添加备注
                 if model['attr'].get('note'):
                     model_str += f" - {model['attr']['note']}"
+                if features:
+                    model_str += f" [{'|'.join(features)}]"
+                    
                 model['desc'] = model_str
             
             return list(self.models.keys())

jarvis/jarvis_platform/base.py

@@ -2,7 +2,7 @@ from abc import ABC, abstractmethod
 import re
 from typing import Dict, List, Tuple
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
-from jarvis.jarvis_utils.utils import get_context_token_count, while_success, while_true
+from jarvis.jarvis_utils.utils import ct, ot, get_context_token_count, while_success, while_true
 
 
 class BasePlatform(ABC):
@@ -53,16 +53,11 @@ class BasePlatform(ABC):
                 )
 
             # Keep original think tag handling
-            response = re.sub(r'<think>.*?</think>', '', response, flags=re.DOTALL)
+            response = re.sub(ot("think")+r'.*?'+ct("think"), '', response, flags=re.DOTALL)
             return response
                 
         return while_true(lambda: while_success(lambda: _chat(), 5), 5)
 
-    @abstractmethod
-    def upload_files(self, file_list: List[str]) -> List[Dict]:
-        """Upload files"""
-        raise NotImplementedError("upload_files is not implemented")
-
     @abstractmethod
     def reset(self):
         """Reset model"""

jarvis/jarvis_platform/kimi.py

@@ -45,7 +45,6 @@ class KimiModel(BasePlatform):
             PrettyOutput.print("KIMI_API_KEY 未设置", OutputType.WARNING)
         self.auth_header = f"Bearer {self.api_key}"
         self.chat_id = ""
-        self.uploaded_files = []  # 存储已上传文件的信息
         self.first_chat = True  # 添加标记，用于判断是否是第一次对话
         self.system_message = ""
 
@@ -77,138 +76,6 @@ class KimiModel(BasePlatform):
             PrettyOutput.print(f"错误：创建会话失败：{e}", OutputType.ERROR)
             return False
 
-    def _get_presigned_url(self, filename: str, action: str) -> Dict:
-        """Get presigned upload URL"""
-        url = "https://kimi.moonshot.cn/api/pre-sign-url"
-        
-        
-        
-        payload = json.dumps({
-            "action": action,
-            "name": os.path.basename(filename)
-        }, ensure_ascii=False)
-        
-        headers = {
-            'Authorization': self.auth_header,
-            'Content-Type': 'application/json'
-        }
-        
-        response = while_success(lambda: requests.post(url, headers=headers, data=payload), sleep_time=5)
-        return response.json()
-
-    def _upload_file(self, file_path: str, presigned_url: str) -> bool:
-        """Upload file to presigned URL"""
-        try:
-            with open(file_path, 'rb') as f:
-                content = f.read()
-                response = while_success(lambda: requests.put(presigned_url, data=content), sleep_time=5)
-                return response.status_code == 200
-        except Exception as e:
-            PrettyOutput.print(f"错误：上传文件失败：{e}", OutputType.ERROR)
-            return False
-
-    def _get_file_info(self, file_data: Dict, name: str, file_type: str) -> Dict:
-        """Get file information"""
-        url = "https://kimi.moonshot.cn/api/file"
-        payload = json.dumps({
-            "type": file_type,
-            "name": name,
-            "object_name": file_data["object_name"],
-            "chat_id": self.chat_id,
-            "file_id": file_data.get("file_id", "")
-        }, ensure_ascii=False)
-        
-        headers = {
-            'Authorization': self.auth_header,
-            'Content-Type': 'application/json'
-        }
-        
-        response = while_success(lambda: requests.post(url, headers=headers, data=payload), sleep_time=5)
-        return response.json()
-
-    def _wait_for_parse(self, file_id: str) -> bool:
-        """Wait for file parsing to complete"""
-        url = "https://kimi.moonshot.cn/api/file/parse_process"
-        headers = {
-            'Authorization': self.auth_header,
-            'Content-Type': 'application/json'
-        }
-        
-        max_retries = 30
-        retry_count = 0
-        
-        while retry_count < max_retries:
-            payload = json.dumps({"ids": [file_id]}, ensure_ascii=False)
-            response = while_success(lambda: requests.post(url, headers=headers, data=payload, stream=True), sleep_time=5)
-            
-            for line in response.iter_lines():
-                if not line:
-                    continue
-                    
-                line = line.decode('utf-8')
-                if not line.startswith("data: "):
-                    continue
-                    
-                try:
-                    data = json.loads(line[6:])
-                    if data.get("event") == "resp":
-                        status = data.get("file_info", {}).get("status")
-                        if status == "parsed":
-                            return True
-                        elif status == "failed":
-                            return False
-                except json.JSONDecodeError:
-                    continue
-            
-            retry_count += 1
-            time.sleep(1)
-        
-        return False
-    def upload_files(self, file_list: List[str]) -> List[Dict]:
-        """Upload file list and return file information"""
-        if not file_list:
-            return []
-
-        
-        if not self.chat_id:
-            if not self._create_chat():
-                raise Exception("Failed to create chat session")
-
-        uploaded_files = []
-        for index, file_path in enumerate(file_list, 1):
-            try:
-                PrettyOutput.print(f"处理文件 [{index}/{len(file_list)}]: {file_path}", OutputType.PROGRESS)
-
-                mime_type, _ = mimetypes.guess_type(file_path)
-                action = "image" if mime_type and mime_type.startswith('image/') else "file"
-                
-                # 获取预签名URL
-                presigned_data = self._get_presigned_url(file_path, action)
-                
-                # 上传文件
-                if self._upload_file(file_path, presigned_data["url"]):
-                    # 获取文件信息
-                    file_info = self._get_file_info(presigned_data, os.path.basename(file_path), action)
-                    file_info = self._get_file_info(presigned_data, os.path.basename(file_path), action)
-                    # 等待文件解析
-
-                    # 只有文件需要解析
-                    if action == "file":
-                        if self._wait_for_parse(file_info["id"]):
-                            uploaded_files.append(file_info)
-                        else:
-                            PrettyOutput.print(f"✗ 文件解析失败: {file_path}", OutputType.WARNING)
-                    else:
-                        uploaded_files.append(file_info)
-                else:
-                    PrettyOutput.print(f"错误：文件上传失败: {file_path}", OutputType.WARNING)
-                    
-            except Exception as e:
-                PrettyOutput.print(f"✗ 处理文件出错 {file_path}: {str(e)}", OutputType.ERROR)
-                continue
-        
-        self.uploaded_files = uploaded_files
-        return uploaded_files
 
     def chat(self, message: str) -> str:
         """Send message and get response"""
@@ -218,15 +85,7 @@ class KimiModel(BasePlatform):
 
         url = f"https://kimi.moonshot.cn/api/chat/{self.chat_id}/completion/stream"
         
-        # 只在第一次对话时带上文件引用
-        refs = []
-        refs_file = []
-        if self.first_chat:
-            if self.uploaded_files:
-                refs = [f["id"] for f in self.uploaded_files]
-                refs_file = self.uploaded_files
-            message = self.system_message + "\n" + message
-            self.first_chat = False
+        
         
         payload = {
             "messages": [{"role": "user", "content": message}],
@@ -235,8 +94,8 @@ class KimiModel(BasePlatform):
             "kimiplus_id": "kimi",
             "use_research": False,
             "use_math": False,
-            "refs": refs,
-            "refs_file": refs_file
+            "refs": [],
+            "refs_file": []
         }
 
         headers = {

jarvis/jarvis_platform/ollama.py

@@ -1,12 +1,12 @@
-import requests
 from typing import List, Dict, Tuple
 from jarvis.jarvis_platform.base import BasePlatform
 import os
-import json
 
-from jarvis.jarvis_utils.input import get_single_line_input
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
+
+import ollama
+
 class OllamaPlatform(BasePlatform):
     """Ollama platform implementation"""
     
@@ -20,11 +20,13 @@ class OllamaPlatform(BasePlatform):
         self.api_base = os.getenv("OLLAMA_API_BASE", "http://localhost:11434")
         self.model_name = os.getenv("JARVIS_MODEL") or "deepseek-r1:1.5b"
         
+        # Setup client based on availability
+        self.client = None
+        self.client = ollama.Client(host=self.api_base)
+        
         # Check if Ollama service is available
         try:
-            response = requests.get(f"{self.api_base}/api/tags")
-            response.raise_for_status()
-            available_models = [model["name"] for model in response.json().get("models", [])]
+            available_models = self._get_available_models()
             
             if not available_models:
                 message = (
@@ -36,9 +38,9 @@ class OllamaPlatform(BasePlatform):
                 PrettyOutput.print(message, OutputType.INFO)
                 PrettyOutput.print("Ollama 没有可用的模型", OutputType.WARNING)
                 
-        except requests.exceptions.ConnectionError:
+        except Exception as e:
             message = (
-                "Ollama 服务未启动或无法连接\n"
+                f"Ollama 服务未启动或无法连接: {str(e)}\n"
                 "请确保您已:\n"
                 "1. 安装 Ollama: https://ollama.ai\n"
                 "2. 启动 Ollama 服务\n"
@@ -50,11 +52,19 @@ class OllamaPlatform(BasePlatform):
         self.messages = []
         self.system_message = ""
 
+    def _get_available_models(self) -> List[str]:
+        """Get list of available models using appropriate method"""
+        models_response = self.client.list() # type: ignore
+        return [model["model"] for model in models_response.get("models", [])]
+
     def get_model_list(self) -> List[Tuple[str, str]]:
         """Get model list"""
-        response = requests.get(f"{self.api_base}/api/tags")
-        response.raise_for_status()
-        return [(model["name"], "") for model in response.json().get("models", [])]
+        try:
+            models = self._get_available_models()
+            return [(model, "") for model in models]
+        except Exception as e:
+            PrettyOutput.print(f"获取模型列表失败: {str(e)}", OutputType.ERROR)
+            return []
 
     def set_model_name(self, model_name: str):
         """Set model name"""
@@ -69,54 +79,44 @@ class OllamaPlatform(BasePlatform):
                 messages.append({"role": "system", "content": self.system_message})
             messages.extend(self.messages)
             messages.append({"role": "user", "content": message})
-            
-            # 构建请求数据
-            data = {
-                "model": self.model_name,
-                "messages": messages,
-                "stream": True  # 启用流式输出
-            }
-            
-            # 发送请求
-            response = requests.post(
-                f"{self.api_base}/api/chat",
-                json=data,
-                stream=True
-            )
-            response.raise_for_status()
-            
-            # 处理流式响应
-            full_response = ""
-            for line in response.iter_lines():
-                if line:
-                    chunk = line.decode()
-                    try:
-                        result = json.loads(chunk)
-                        if "message" in result and "content" in result["message"]:
-                            text = result["message"]["content"]
-                            if not self.suppress_output:
-                                PrettyOutput.print_stream(text)
-                            full_response += text
-                    except json.JSONDecodeError:
-                        continue
-                        
-            if not self.suppress_output:
-                PrettyOutput.print_stream_end()
-            
-            # 更新消息历史
-            self.messages.append({"role": "user", "content": message})
-            self.messages.append({"role": "assistant", "content": full_response})
-            
-            return full_response
+
+            return self._chat_with_package(messages)
             
         except Exception as e:
             PrettyOutput.print(f"对话失败: {str(e)}", OutputType.ERROR)
             raise Exception(f"Chat failed: {str(e)}")
 
-    def upload_files(self, file_list: List[str]) -> List[Dict]:
-        """Upload files (Ollama does not support file upload)"""
-        PrettyOutput.print("Ollama 不支持文件上传", output_type=OutputType.WARNING)
-        return []
+    def _chat_with_package(self, messages: List[Dict]) -> str:
+        """Chat using the ollama package"""
+        # The client should not be None here due to the check in the chat method
+        if not self.client:
+            raise ValueError("Ollama client is not initialized")
+            
+        # Use ollama-python's streaming API
+        stream = self.client.chat(
+            model=self.model_name,
+            messages=messages,
+            stream=True
+        )
+        
+        # Process the streaming response
+        full_response = ""
+        for chunk in stream:
+            if "message" in chunk and "content" in chunk["message"]:
+                text = chunk["message"]["content"]
+                if not self.suppress_output:
+                    PrettyOutput.print_stream(text)
+                full_response += text
+                    
+        if not self.suppress_output:
+            PrettyOutput.print_stream_end()
+        
+        # Update message history
+        self.messages.append({"role": "user", "content": messages[-1]["content"]})
+        self.messages.append({"role": "assistant", "content": full_response})
+        
+        return full_response
+
         
     def reset(self):
         """Reset model state"""
@@ -137,17 +137,3 @@ class OllamaPlatform(BasePlatform):
         """Set system message"""
         self.system_message = message
         self.reset()  # 重置会话以应用新的系统消息 
-
-
-if __name__ == "__main__":
-    try:
-        ollama = OllamaPlatform()
-        while True:
-            try:
-                message = get_single_line_input("输入问题 (Ctrl+C 退出)")
-                ollama.chat_until_success(message)
-            except KeyboardInterrupt:
-                print("再见!")
-                break
-    except Exception as e:
-        PrettyOutput.print(f"程序异常退出: {str(e)}", OutputType.ERROR)

jarvis/jarvis_platform/openai.py

@@ -7,10 +7,6 @@ from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 class OpenAIModel(BasePlatform):
     platform_name = "openai"
 
-    def upload_files(self, file_list: List[str]):
-        """Upload files"""
-        PrettyOutput.print("OpenAI does not support file upload", OutputType.WARNING)
-    
     def __init__(self):
         """
         Initialize OpenAI model