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

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
             }
         },

jarvis/tools/registry.py

@@ -39,7 +39,7 @@ class ToolRegistry:
             if file_path.name in ["base.py", "__init__.py", "registry.py"]:
                 continue
                 
-            self.register_tool_by_file(file_path)
+            self.register_tool_by_file(str(file_path))
 
     def _load_external_tools(self):
         """从~/.jarvis_tools加载外部工具"""
@@ -53,7 +53,7 @@ class ToolRegistry:
             if file_path.name == "__init__.py":
                 continue
                 
-            self.register_tool_by_file(file_path)
+            self.register_tool_by_file(str(file_path))
 
     def register_tool_by_file(self, file_path: str):
         """从指定文件加载并注册工具
@@ -65,19 +65,19 @@ class ToolRegistry:
             bool: 是否成功加载工具
         """
         try:
-            file_path = Path(file_path).resolve()  # 获取绝对路径
-            if not file_path.exists() or not file_path.is_file():
-                PrettyOutput.print(f"文件不存在: {file_path}", OutputType.ERROR)
+            p_file_path = Path(file_path).resolve()  # 获取绝对路径
+            if not p_file_path.exists() or not p_file_path.is_file():
+                PrettyOutput.print(f"File does not exist: {p_file_path}", OutputType.ERROR)
                 return False
                 
             # 动态导入模块
-            module_name = file_path.stem
-            spec = importlib.util.spec_from_file_location(module_name, file_path)
+            module_name = p_file_path.stem
+            spec = importlib.util.spec_from_file_location(module_name, p_file_path) # type: ignore
             if not spec or not spec.loader:
-                PrettyOutput.print(f"无法加载模块: {file_path}", OutputType.ERROR)
+                PrettyOutput.print(f"Failed to load module: {p_file_path}", OutputType.ERROR)
                 return False
                 
-            module = importlib.util.module_from_spec(spec)
+            module = importlib.util.module_from_spec(spec) # type: ignore
             sys.modules[module_name] = module  # 添加到 sys.modules 以支持相对导入
             spec.loader.exec_module(module)
             
@@ -101,18 +101,18 @@ class ToolRegistry:
                         parameters=tool_instance.parameters,
                         func=tool_instance.execute
                     )
-                    PrettyOutput.print(f"从 {file_path} 加载工具: {tool_instance.name}: {tool_instance.description}", OutputType.SUCCESS)
+                    PrettyOutput.print(f"Loaded tool from {p_file_path}: {tool_instance.name}: {tool_instance.description}", OutputType.SUCCESS)
                     tool_found = True
                     break
                     
             if not tool_found:
-                PrettyOutput.print(f"文件中未找到有效的工具类: {file_path}", OutputType.WARNING)
+                PrettyOutput.print(f"No valid tool class found in the file: {p_file_path}", OutputType.WARNING)
                 return False
                 
             return True
             
         except Exception as e:
-            PrettyOutput.print(f"加载工具失败 {file_path.name}: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Failed to load tool from {p_file_path.name}: {str(e)}", OutputType.ERROR)
             return False
 
     def register_tool(self, name: str, description: str, parameters: Dict, func: Callable):
@@ -149,16 +149,16 @@ class ToolRegistry:
                 try:
                     args = json.loads(args)
                 except json.JSONDecodeError:
-                    PrettyOutput.print(f"工具参数格式无效: {name}", OutputType.ERROR)
+                    PrettyOutput.print(f"Invalid tool parameters format: {name}", OutputType.ERROR)
                     return ""
 
             # 显示工具调用信息
-            PrettyOutput.section(f"执行工具: {name}", OutputType.TOOL)
+            PrettyOutput.section(f"Executing tool: {name}", OutputType.TOOL)
             if isinstance(args, dict):
                 for key, value in args.items():
-                    PrettyOutput.print(f"参数: {key} = {value}", OutputType.DEBUG)
+                    PrettyOutput.print(f"Parameter: {key} = {value}", OutputType.DEBUG)
             else:
-                PrettyOutput.print(f"参数: {args}", OutputType.DEBUG)
+                PrettyOutput.print(f"Parameter: {args}", OutputType.DEBUG)
             
             # 执行工具调用
             result = self.execute_tool(name, args)
@@ -169,58 +169,58 @@ class ToolRegistry:
                 stderr = result.get("stderr", "")
                 output_parts = []
                 if stdout:
-                    output_parts.append(f"输出:\n{stdout}")
+                    output_parts.append(f"Output:\n{stdout}")
                 if stderr:
-                    output_parts.append(f"错误:\n{stderr}")
+                    output_parts.append(f"Error:\n{stderr}")
                 output = "\n\n".join(output_parts)
-                output = "没有输出和错误" if not output else output
-                PrettyOutput.section("执行成功", OutputType.SUCCESS)
+                output = "No output and error" if not output else output
+                PrettyOutput.section("Execution successful", OutputType.SUCCESS)
                 
                 # 如果输出超过4k字符，使用大模型总结
                 if len(output) > self.max_context_length:
                     try:
-                        PrettyOutput.print("输出较长，正在总结...", OutputType.PROGRESS)
+                        PrettyOutput.print("Output is too long, summarizing...", OutputType.PROGRESS)
                         model = PlatformRegistry.get_global_platform_registry().get_normal_platform()
                         
                         # 如果输出超过最大上下文长度，只取最后部分
                         max_len = self.max_context_length
                         if len(output) > max_len:
                             output_to_summarize = output[-max_len:]
-                            truncation_notice = f"\n(注意: 由于输出过长，仅总结最后{max_len}字符)"
+                            truncation_notice = f"\n(Note: Due to the length of the output, only the last {max_len} characters are summarized)"
                         else:
                             output_to_summarize = output
                             truncation_notice = ""
 
-                        prompt = f"""请总结以下工具执行结果，提取关键信息和重要结果。注意：
-1. 保留所有重要的数值、路径、错误信息等关键数据
-2. 保持结果的准确性
-3. 用简洁的语言描述主要内容
-4. 如果有错误信息，确保包含在总结中
+                        prompt = f"""Please summarize the execution result of the following tool, extracting key information and important results. Note:
+1. Keep all important numerical values, paths, error information, etc.
+2. Maintain the accuracy of the results
+3. Describe the main content in concise language
+4. If there is error information, ensure it is included in the summary
 
-工具名称: {name}
-执行结果:
+Tool name: {name}
+Execution result:
 {output_to_summarize}
 
-请提供总结："""
+Please provide a summary:"""
 
-                        summary = model.chat(prompt)
-                        output = f"""--- 原始输出较长，以下是总结 ---{truncation_notice}
+                        summary = model.chat_until_success(prompt)
+                        output = f"""--- Original output is too long, here is the summary ---{truncation_notice}
 
 {summary}
 
---- 总结结束 ---"""
+--- Summary ends ---"""
                         
                     except Exception as e:
-                        PrettyOutput.print(f"总结失败: {str(e)}", OutputType.ERROR)
-                        output = f"输出较长 ({len(output)} 字符)，建议查看原始输出。\n前300字符预览:\n{output[:300]}..."
+                        PrettyOutput.print(f"Summary failed: {str(e)}", OutputType.ERROR)
+                        output = f"Output is too long ({len(output)} characters), it is recommended to view the original output.\nPreview of the first 300 characters:\n{output[:300]}..."
             
             else:
                 error_msg = result["error"]
-                output = f"执行失败: {error_msg}"
-                PrettyOutput.section("执行失败", OutputType.ERROR)
+                output = f"Execution failed: {error_msg}"
+                PrettyOutput.section("Execution failed", OutputType.ERROR)
                 
             return output
             
         except Exception as e:
-            PrettyOutput.print(f"执行工具失败: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Tool execution failed: {str(e)}", OutputType.ERROR)
             return f"Tool call failed: {str(e)}"