jarvis-ai-assistant 0.1.96__py3-none-any.whl → 0.1.97__py3-none-any.whl

jarvis/models/registry.py

@@ -19,7 +19,7 @@ REQUIRED_METHODS = [
 ]
 
 class PlatformRegistry:
-    """平台注册器"""
+    """Platform registry"""
 
     global_platform_name = "kimi"
     global_platform_registry = None
@@ -37,19 +37,19 @@ class PlatformRegistry:
 
                 pass
             except Exception as e:
-                PrettyOutput.print(f"创建平台目录失败: {str(e)}", OutputType.ERROR)
+                PrettyOutput.print(f"Create platform directory failed: {str(e)}", OutputType.ERROR)
                 return ""
         return user_platform_dir
 
     @staticmethod
     def check_platform_implementation(platform_class: Type[BasePlatform]) -> bool:
-        """检查平台类是否实现了所有必要的方法
+        """Check if the platform class implements all necessary methods
         
         Args:
-            platform_class: 要检查的平台类
+            platform_class: The platform class to check
             
         Returns:
-            bool: 是否实现了所有必要的方法
+            bool: Whether all necessary methods are implemented
         """
         missing_methods = []
         
@@ -68,11 +68,11 @@ class PlatformRegistry:
             sig = inspect.signature(method)
             method_params = [p for p in sig.parameters if p != 'self']
             if len(method_params) != len(params):
-                missing_methods.append(f"{method_name}(参数不匹配)")
+                missing_methods.append(f"{method_name}(parameter mismatch)")
         
         if missing_methods:
             PrettyOutput.print(
-                f"平台 {platform_class.__name__} 缺少必要的方法: {', '.join(missing_methods)}", 
+                f"Platform {platform_class.__name__} is missing necessary methods: {', '.join(missing_methods)}", 
                 OutputType.ERROR
             )
             return False
@@ -81,19 +81,19 @@ class PlatformRegistry:
 
     @staticmethod
     def load_platform_from_dir(directory: str) -> Dict[str, Type[BasePlatform]]:
-        """从指定目录加载平台
+        """Load platforms from specified directory
         
         Args:
-            directory: 平台目录路径
+            directory: Platform directory path
             
         Returns:
-            Dict[str, Type[BasePlatform]]: 平台名称到平台类的映射
+            Dict[str, Type[BasePlatform]]: Platform name to platform class mapping
         """
         platforms = {}
         
         # 确保目录存在
         if not os.path.exists(directory):
-            PrettyOutput.print(f"平台目录不存在: {directory}", OutputType.ERROR)
+            PrettyOutput.print(f"Platform directory does not exist: {directory}", OutputType.ERROR)
             return platforms
             
         # 获取目录的包名
@@ -127,18 +127,18 @@ class PlatformRegistry:
                             if not PlatformRegistry.check_platform_implementation(obj):
                                 continue
                             if not PlatformRegistry.suppress_output:
-                                PrettyOutput.print(f"从 {os.path.join(directory, filename)} 加载平台：{obj.platform_name}", OutputType.SUCCESS)
-                            platforms[obj.platform_name] = obj
+                                PrettyOutput.print(f"Load platform from {os.path.join(directory, filename)}: {obj.platform_name}", OutputType.SUCCESS) # type: ignore
+                            platforms[obj.platform_name] = obj # type: ignore
                             break
                 except Exception as e:
-                    PrettyOutput.print(f"加载平台 {module_name} 失败: {str(e)}", OutputType.ERROR)
+                    PrettyOutput.print(f"Load platform {module_name} failed: {str(e)}", OutputType.ERROR)
         
         return platforms
 
 
     @staticmethod
     def get_global_platform_registry():
-        """获取全局平台注册器"""
+        """Get global platform registry"""
         if PlatformRegistry.global_platform_registry is None:
             PlatformRegistry.global_platform_registry = PlatformRegistry()
             
@@ -154,58 +154,57 @@ class PlatformRegistry:
         return PlatformRegistry.global_platform_registry
     
     def __init__(self):
-        """初始化平台注册器
-        """
+        """Initialize platform registry"""
         self.platforms: Dict[str, Type[BasePlatform]] = {}
 
     def get_normal_platform(self) -> BasePlatform:
         platform_name = os.environ.get("JARVIS_PLATFORM", "kimi")
         model_name = os.environ.get("JARVIS_MODEL", "kimi")
         platform = self.create_platform(platform_name)
-        platform.set_model_name(model_name)
-        return platform
+        platform.set_model_name(model_name) # type: ignore
+        return platform # type: ignore
     
     def get_codegen_platform(self) -> BasePlatform:
         platform_name = os.environ.get("JARVIS_CODEGEN_PLATFORM", os.environ.get("JARVIS_PLATFORM", "kimi"))
         model_name = os.environ.get("JARVIS_CODEGEN_MODEL", os.environ.get("JARVIS_MODEL", "kimi"))
         platform = self.create_platform(platform_name)
-        platform.set_model_name(model_name)
-        return platform
+        platform.set_model_name(model_name) # type: ignore
+        return platform # type: ignore
     
     def get_cheap_platform(self) -> BasePlatform:
         platform_name = os.environ.get("JARVIS_CHEAP_PLATFORM", os.environ.get("JARVIS_PLATFORM", "kimi"))
         model_name = os.environ.get("JARVIS_CHEAP_MODEL", os.environ.get("JARVIS_MODEL", "kimi"))
         platform = self.create_platform(platform_name)
-        platform.set_model_name(model_name)
-        return platform
+        platform.set_model_name(model_name) # type: ignore
+        return platform # type: ignore
     
     def get_thinking_platform(self) -> BasePlatform:
         platform_name = os.environ.get("JARVIS_THINKING_PLATFORM", os.environ.get("JARVIS_PLATFORM", "kimi"))
         model_name = os.environ.get("JARVIS_THINKING_MODEL", os.environ.get("JARVIS_MODEL", "kimi"))
         platform = self.create_platform(platform_name)
-        platform.set_model_name(model_name)
-        return platform
+        platform.set_model_name(model_name) # type: ignore
+        return platform # type: ignore
 
     def register_platform(self, name: str, platform_class: Type[BasePlatform]):
-        """注册平台类
+        """Register platform class
         
         Args:
-            name: 平台名称
-            model_class: 平台类
+            name: Platform name
+            model_class: Platform class
         """
         self.platforms[name] = platform_class
             
     def create_platform(self, name: str) -> Optional[BasePlatform]:
-        """创建平台实例
+        """Create platform instance
         
         Args:
-            name: 平台名称
+            name: Platform name
             
         Returns:
-            BasePlatform: 平台实例
+            BasePlatform: Platform instance
         """
         if name not in self.platforms:
-            PrettyOutput.print(f"未找到平台: {name}", OutputType.ERROR)
+            PrettyOutput.print(f"Platform not found: {name}", OutputType.ERROR)
             return None
             
         try:
@@ -213,10 +212,10 @@ class PlatformRegistry:
             platform = self.platforms[name]()
             return platform
         except Exception as e:
-            PrettyOutput.print(f"创建平台失败: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Create platform failed: {str(e)}", OutputType.ERROR)
             return None
             
     def get_available_platforms(self) -> List[str]:
-        """获取可用平台列表"""
+        """Get available platform list"""
         return list(self.platforms.keys()) 
     

jarvis/tools/ask_user.py

@@ -4,13 +4,13 @@ from jarvis.utils import get_multiline_input, PrettyOutput, OutputType
 
 class AskUserTool:
     name="ask_user"
-    description="""当缺少完成任务的信息或有关键决策信息缺失时，询问用户。用户可以输入多行文本，空行结束输入。使用场景：1. 需要用户提供更多信息来完成任务；2. 需要用户做出关键决策；3. 需要用户确认某些重要操作；4. 需要用户提供额外信息"""
+    description="""Ask the user when information needed to complete the task is missing or when critical decision information is lacking. Users can input multiple lines of text, ending with an empty line. Use cases: 1. Need user to provide more information to complete the task; 2. Need user to make critical decisions; 3. Need user to confirm important operations; 4. Need user to provide additional information"""
     parameters={
         "type": "object",
         "properties": {
             "question": {
                 "type": "string",
-                "description": "要询问用户的问题"
+                "description": "The question to ask the user"
             }
         },
         "required": ["question"]
@@ -34,12 +34,12 @@ class AskUserTool:
             PrettyOutput.print(question, OutputType.SYSTEM)
             
             # 获取用户输入
-            user_response = get_multiline_input("请输入您的回答（输入空行结束）")
+            user_response = get_multiline_input("Please enter your answer (input empty line to end)")
             
             if user_response == "__interrupt__":
                 return {
                     "success": False,
-                    "error": "用户取消了输入"
+                    "error": "User canceled input"
                 }
             
             return {
@@ -50,5 +50,5 @@ class AskUserTool:
         except Exception as e:
             return {
                 "success": False,
-                "error": f"询问用户失败: {str(e)}"
+                "error": f"Failed to ask user: {str(e)}"
             } 

jarvis/tools/base.py

@@ -11,7 +11,7 @@ class Tool:
         self.func = func
 
     def to_dict(self) -> Dict:
-        """转换为工具格式"""
+        """Convert to tool format"""
         return {
             "name": self.name,
             "description": self.description,
@@ -19,5 +19,5 @@ class Tool:
         }
 
     def execute(self, arguments: Dict) -> Dict[str, Any]:
-        """执行工具函数"""
+        """Execute tool function"""
         return self.func(arguments)

jarvis/tools/chdir.py

@@ -6,13 +6,13 @@ class ChdirTool:
     """修改当前工作目录的工具"""
     
     name = "chdir"
-    description = "修改当前工作目录"
+    description = "Change current working directory"
     parameters = {
         "type": "object",
         "properties": {
             "path": {
                 "type": "string",
-                "description": "要切换到的目录路径，支持相对路径和绝对路径"
+                "description": "Directory path to switch to, supports both relative and absolute paths"
             }
         },
         "required": ["path"]
@@ -38,14 +38,14 @@ class ChdirTool:
             if not os.path.exists(path):
                 return {
                     "success": False,
-                    "error": f"目录不存在: {path}"
+                    "error": f"Directory does not exist: {path}"
                 }
                 
             # 检查是否是目录
             if not os.path.isdir(path):
                 return {
                     "success": False,
-                    "error": f"路径不是目录: {path}"
+                    "error": f"The path is not a directory: {path}"
                 }
                 
             # 尝试切换目录
@@ -54,27 +54,27 @@ class ChdirTool:
             
             return {
                 "success": True,
-                "stdout": f"已切换工作目录:\n从: {old_path}\n到: {path}",
+                "stdout": f"Changed working directory:\nFrom: {old_path}\nTo: {path}",
                 "stderr": ""
             }
             
         except PermissionError:
             return {
                 "success": False,
-                "error": f"没有权限访问目录: {path}"
+                "error": f"No permission to access directory: {path}"
             }
         except Exception as e:
             return {
                 "success": False,
-                "error": f"切换目录失败: {str(e)}"
+                "error": f"Failed to switch directory: {str(e)}"
             }
             
 def main():
     """命令行直接运行工具"""
     import argparse
     
-    parser = argparse.ArgumentParser(description='修改当前工作目录')
-    parser.add_argument('path', help='要切换到的目录路径')
+    parser = argparse.ArgumentParser(description='Change current working directory')
+    parser.add_argument('path', help='Directory path to switch to, supports both relative and absolute paths')
     args = parser.parse_args()
     
     tool = ChdirTool()

jarvis/tools/codebase_qa.py

@@ -7,21 +7,21 @@ class CodebaseQATool:
     """代码库问答工具，用于回答关于代码库的问题"""
     
     name = "codebase_qa"
-    description = "回答关于代码库的问题，可以查询和理解代码的功能、结构和实现细节"
+    description = "Answer questions about the codebase, can query and understand code functionality, structure, and implementation details"
     parameters = {
         "type": "object",
         "properties": {
             "dir": {
                 "type": "string",
-                "description": "项目根目录"
+                "description": "Project root directory"
             },
             "question": {
                 "type": "string",
-                "description": "关于代码库的问题"
+                "description": "Question about the codebase"
             },
             "top_k": {
                 "type": "integer",
-                "description": "搜索相关文件的数量",
+                "description": "Number of relevant files to search",
                 "default": 5
             }
         },

jarvis/tools/coder.py

@@ -7,21 +7,21 @@ class CoderTool:
     """代码修改工具"""
     
     name = "coder"
-    description = "分析并修改现有代码，用于实现新功能、修复bug、重构代码等。能理解代码上下文并进行精确的代码编辑。"
+    description = "Analyze and modify existing code for implementing new features, fixing bugs, refactoring code, etc. Can understand code context and perform precise code edits."
     parameters = {
         "feature": {
             "type": "string",
-            "description": "要实现的功能描述或需要修改的内容，例如：'添加日志功能'、'修复内存泄漏'、'优化性能'等",
+            "description": "Description of the feature to implement or content to modify, e.g., 'add logging functionality', 'fix memory leak', 'optimize performance', etc.",
             "required": True
         },
         "dir": {
             "type": "string", 
-            "description": "项目根目录，默认为当前目录",
+            "description": "Project root directory, defaults to current directory",
             "required": False
         },
         "language": {
             "type": "string",
-            "description": "项目的主要编程语言，默认为python",
+            "description": "Main programming language of the project, defaults to python",
             "required": False
         }
     }

jarvis/tools/file_ops.py

@@ -7,7 +7,7 @@ from jarvis.utils import OutputType, PrettyOutput
 
 class FileOperationTool:
     name = "file_operation"
-    description = "文件操作 (read/write/append/exists)"
+    description = "File operations (read/write/append/exists)"
     parameters = {
         "type": "object",
         "properties": {

jarvis/tools/generator.py

@@ -7,25 +7,25 @@ from jarvis.utils import OutputType, PrettyOutput
 
 class ToolGeneratorTool:
     name = "generate_tool"
-    description = "生成新的工具代码并自动注册到Jarvis，自动扩充Jarvis的能力"
+    description = "Generate new tool code and automatically register it to Jarvis, automatically expanding Jarvis's capabilities"
     parameters = {
         "type": "object",
         "properties": {
             "tool_name": {
                 "type": "string",
-                "description": "工具的名称（snake_case格式）"
+                "description": "Name of the tool (in snake_case format)"
             },
             "class_name": {
                 "type": "string",
-                "description": "工具类的名称（PascalCase格式）"
+                "description": "Name of the tool class (in PascalCase format)"
             },
             "description": {
                 "type": "string",
-                "description": "工具的功能描述"
+                "description": "Description of the tool's functionality"
             },
             "parameters": {
                 "type": "object",
-                "description": "工具参数的JSON Schema定义"
+                "description": "JSON Schema definition of tool parameters"
             }
         },
         "required": ["tool_name", "class_name", "description", "parameters"]
@@ -44,14 +44,14 @@ class ToolGeneratorTool:
         """使用大模型生成工具代码"""
         model = PlatformRegistry.get_global_platform_registry().get_codegen_platform()
 
-        prompt = f"""请生成一个Python工具类的代码，要求如下，除了代码，不要输出任何内容：
+        prompt = f"""Please generate the code for a Python tool class, with the following requirements, and do not output any content except the code:
 
-1. 类名: {class_name}
-2. 工具名称: {tool_name}
-3. 功能描述: {description}
-4. 参数定义: {parameters}
+1. Class name: {class_name}
+2. Tool name: {tool_name}
+3. Function description: {description}
+4. Parameter definition: {parameters}
 
-严格按照以下格式生成代码(各函数的参数和返回值一定要与示例一致)：
+Strictly follow the following format to generate code (the parameters and return values of each function must be consistent with the example):
 
 ```python
 from typing import Dict, Any, Protocol, Optional
@@ -60,7 +60,7 @@ from jarvis.models.registry import ModelRegistry
 
 class ExampleTool:
     name = "example_tool"
-    description = "示例工具"
+    description = "Example tool"
     parameters = {{
         "type": "object",
         "properties": {{
@@ -70,22 +70,22 @@ class ExampleTool:
     }}
 
     def __init__(self):
-        self.model = ModelRegistry.get_global_model()
+        self.model = ModelRegistry.get_global_platform_registry().get_normal_platform()
 
     def execute(self, args: Dict) -> Dict[str, Any]:
         try:
-            # 验证参数示例
+            # Validate parameter example
             if "param1" not in args:
-                return {{"success": False, "error": "缺少必需参数: param1"}}
+                return {{"success": False, "error": "Missing required parameter: param1"}}
             
-            # 记录操作示例
-            PrettyOutput.print(f"处理参数: {{args['param1']}}", OutputType.INFO)
+            # Record operation example
+            PrettyOutput.print(f"Processing parameter: {{args['param1']}}", OutputType.INFO)
 
-            # 使用大模型示例
-            response = self.model.chat("prompt")
+            # Use large model example
+            response = self.model.chat_until_success("prompt")
             
-            # 实现具体功能
-            result = "处理结果"
+            # Implement specific functionality
+            result = "Processing result"
             
             return {{
                 "success": True,
@@ -101,7 +101,7 @@ class ExampleTool:
 ```"""
 
         # 调用模型生成代码
-        response = model.chat(prompt)
+        response = model.chat_until_success(prompt)
 
         # 提取代码块
         code_start = response.find("```python")
@@ -147,7 +147,7 @@ class ExampleTool:
                     f.write("# Jarvis Tools\n")
 
             # 注册工具
-            success = ToolRegistry.get_global_tool_registry().register_tool_by_file(tool_file)
+            success = ToolRegistry.get_global_tool_registry().register_tool_by_file(str(tool_file))
             if not success:
                 return {
                     "success": False,

jarvis/tools/methodology.py

@@ -8,22 +8,22 @@ class MethodologyTool:
     """经验管理工具"""
     
     name = "methodology"
-    description = "管理问题处理方法论，支持添加、更新、删除操作"
+    description = "Manage problem-solving methodologies, supporting add, update, and delete operations"
     parameters = {
         "type": "object",
         "properties": {
             "operation": {
                 "type": "string",
-                "description": "操作类型 (delete/update/add)",
+                "description": "Operation type (delete/update/add)",
                 "enum": ["delete", "update", "add"]
             },
             "problem_type": {
                 "type": "string",
-                "description": "问题类型，例如：code_review, bug_fix 等"
+                "description": "Problem type, e.g., code_review, bug_fix, etc."
             },
             "content": {
                 "type": "string",
-                "description": "方法论内容 (update/add 时必需)",
+                "description": "Methodology content (required for update/add)",
                 "optional": True
             }
         },

jarvis/tools/rag.py

@@ -5,21 +5,21 @@ from jarvis.jarvis_rag.main import RAGTool as RAGCore
 
 class RAGTool:
     name = "rag"
-    description = "基于文档目录进行问答，支持多种文档格式（txt、pdf、docx等）"
+    description = "Ask questions based on a document directory, supporting multiple document formats (txt, pdf, docx, etc.)"
     parameters = {
         "type": "object",
         "properties": {
             "dir": {
                 "type": "string",
-                "description": "文档目录路径，支持相对路径和绝对路径"
+                "description": "Document directory path, supports both relative and absolute paths"
             },
             "question": {
                 "type": "string",
-                "description": "要询问的问题"
+                "description": "The question to ask"
             },
             "rebuild_index": {
                 "type": "boolean",
-                "description": "是否重建索引",
+                "description": "Whether to rebuild the index",
                 "default": False
             }
         },