jarvis-ai-assistant 0.1.111__py3-none-any.whl → 0.1.112__py3-none-any.whl

jarvis/jarvis_tools/tool_generator.py

@@ -0,0 +1,182 @@
+"""
+Tool Generator Tool - Automatically creates new tools using LLM
+"""
+from pathlib import Path
+import re
+from typing import Dict, Any
+from jarvis.jarvis_platform.registry import PlatformRegistry
+
+class ToolGenerator:
+    name = "tool_generator"
+    description = "Generates new tools using LLM that integrate with the system"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "tool_name": {
+                "type": "string",
+                "description": "Name of the new tool"
+            },
+            "description": {
+                "type": "string", 
+                "description": "Description of the tool's purpose"
+            },
+            "input_spec": {
+                "type": "string",
+                "description": "Specification of required inputs and functionality"
+            }
+        },
+        "required": ["tool_name", "description", "input_spec"]
+    }
+    
+    def execute(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Generate and save a new tool using LLM"""
+        # Get fresh model instance for each execution
+        model = PlatformRegistry.get_global_platform_registry().get_codegen_platform()
+        
+        try:
+            tool_name = arguments["tool_name"]
+            description = arguments["description"]
+            input_spec = arguments["input_spec"]
+            
+            # Generate tool implementation using LLM
+            prompt = self._create_prompt(tool_name, description, input_spec)
+            llm_response = model.chat_until_success(prompt)
+            
+            # Extract implementation with more flexible parsing
+            implementation = self._extract_code(llm_response)
+            if not implementation:
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": "Could not extract valid Python code from LLM response"
+                }
+            
+            # Validate return value format
+            if not self._validate_return_value_format(implementation):
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": "Generated tool does not follow required return value format"
+                }
+            
+            # Save the new tool
+            tools_dir = Path.home() / ".jarvis" / "tools"
+            tools_dir.mkdir(parents=True, exist_ok=True)
+            tool_file = tools_dir / f"{tool_name}.py"
+            
+            with open(tool_file, "w") as f:
+                f.write(implementation)
+            
+            return {
+                "success": True,
+                "stdout": f"Tool successfully generated at: {tool_file}",
+                "stderr": ""
+            }
+            
+        except Exception as e:
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"Tool generation failed: {str(e)}"
+            }
+    
+    def _create_prompt(self, tool_name: str, description: str, input_spec: str) -> str:
+        """Create the LLM prompt for tool generation"""
+        example_code = '''
+<TOOL>
+from typing import Dict, Any
+from jarvis.utils import OutputType, PrettyOutput
+from jarvis.jarvis_platform.registry import PlatformRegistry
+
+class CustomTool:
+    name = "Tool name"              # Tool name used when calling
+    description = "Tool description"       # Tool purpose
+    parameters = {                # Parameters JSON Schema
+        "type": "object",
+        "properties": {
+            "param1": {
+                "type": "string",
+                "description": "Parameter description"
+            }
+        },
+        "required": ["param1"]
+    }
+
+    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute the tool functionality
+        
+        Args:
+            args: Parameters passed to the tool
+            
+        Returns:
+            {
+                "success": bool,
+                "stdout": str,
+                "stderr": str,
+            }
+        """
+        try:
+            # Implement the tool logic here
+            # Use LLM
+            # model = PlatformRegistry.get_global_platform_registry().get_codegen_platform() 
+            # result = model.chat_until_success(prompt)
+
+            result = "Tool result"
+            return {
+                "success": True,
+                "stdout": result,
+                "stderr": ""
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": str(e)
+            }
+</TOOL>
+'''
+
+
+        return f'''Create a Python tool class that integrates with the Jarvis system. Follow these requirements:
+1. Class name: {tool_name.capitalize()}Tool
+2. Description: {description}
+3. Input specification: {input_spec}
+4. Must include these class attributes:
+   - name: str (tool identifier)
+   - description: str (tool purpose)
+   - parameters: dict (JSON schema for inputs)
+5. Must implement execute(self, args: Dict) -> Dict method
+6. The execute method MUST return a dictionary with these exact fields:
+   - success: bool (indicating operation success)
+   - stdout: str (primary output/result)
+   - stderr: str (error message if any)
+7. Must handle errors gracefully
+8. Return ONLY the Python implementation code
+9. The code should be complete and ready to use.
+10. Output the code in the following format:
+<TOOL>
+{example_code}
+</TOOL>
+
+Example:
+{example_code}
+'''
+    
+    def _extract_code(self, response: str) -> str:
+        """Flexibly extract Python code from LLM response"""
+        # Find the first occurrence of <TOOL> and </TOOL>
+        sm = re.search(r'<TOOL>(.*?)</TOOL>', response, re.DOTALL)
+        if sm:
+            return sm.group(1)
+        return ""
+    
+    def _validate_return_value_format(self, code: str) -> bool:
+        """Validate that execute method returns correct format"""
+        required_fields = ["success", "stdout", "stderr"]
+        # Look for execute method
+        if "def execute(self, args: Dict) -> Dict:" not in code and \
+           "def execute(self, args: Dict) -> Dict[str, Any]:" not in code:
+            return False
+        
+        # Check for required fields in return statement
+        return all(field in code for field in required_fields)

jarvis/utils.py

@@ -322,7 +322,7 @@ def get_multiline_input(tip: str) -> str:
             lines.append(line)
             
     except KeyboardInterrupt:
-        PrettyOutput.print("Input cancelled", OutputType.INFO)
+        PrettyOutput.print("输入已取消", OutputType.INFO)
         return ""
     
     return "\n".join(lines)
@@ -348,7 +348,7 @@ def init_env():
                         except ValueError:
                             continue
         except Exception as e:
-            PrettyOutput.print(f"Warning: Failed to read {env_file}: {e}", OutputType.WARNING)
+            PrettyOutput.print(f"警告: 读取 {env_file} 失败: {e}", OutputType.WARNING)
     
     
 def while_success(func, sleep_time: float = 0.1):
@@ -356,7 +356,7 @@ def while_success(func, sleep_time: float = 0.1):
         try:
             return func()
         except Exception as e:
-            PrettyOutput.print(f"Execution failed: {str(e)}, retry in {sleep_time}s...", OutputType.ERROR)
+            PrettyOutput.print(f"执行失败: {str(e)}, 等待 {sleep_time}s...", OutputType.ERROR)
             time.sleep(sleep_time)
             continue
 
@@ -366,7 +366,7 @@ def while_true(func, sleep_time: float = 0.1):
         ret = func()
         if ret:
             break
-        PrettyOutput.print(f"Execution failed, retry in {sleep_time}s...", OutputType.WARNING)
+        PrettyOutput.print(f"执行失败, 等待 {sleep_time}s...", OutputType.WARNING)
         time.sleep(sleep_time)
     return ret
 
@@ -433,7 +433,7 @@ def load_rerank_model():
     model_name = "BAAI/bge-reranker-v2-m3"
     cache_dir = os.path.expanduser("~/.cache/huggingface/hub")
     
-    PrettyOutput.print(f"Loading reranking model: {model_name}...", OutputType.INFO)
+    PrettyOutput.print(f"加载重排序模型: {model_name}...", OutputType.INFO)
     
     try:
         # Load model and tokenizer
@@ -484,7 +484,7 @@ def is_long_context(files: list) -> bool:
                 if total_tokens > threshold:
                     return True
         except Exception as e:
-            PrettyOutput.print(f"Failed to read file {file_path}: {e}", OutputType.WARNING)
+            PrettyOutput.print(f"读取文件 {file_path} 失败: {e}", OutputType.WARNING)
             continue
             
     return total_tokens > threshold
@@ -511,13 +511,13 @@ def _create_methodology_embedding(embedding_model: Any, methodology_text: str) -
         vector = np.array(embedding.cpu().numpy(), dtype=np.float32)
         return vector[0]  # Return first vector, because we only encoded one text
     except Exception as e:
-        PrettyOutput.print(f"Failed to create methodology embedding vector: {str(e)}", OutputType.ERROR)
+        PrettyOutput.print(f"创建方法论嵌入向量失败: {str(e)}", OutputType.ERROR)
         return np.zeros(1536, dtype=np.float32)
 
 
 def load_methodology(user_input: str) -> str:
     """Load methodology and build vector index"""
-    PrettyOutput.print("Loading methodology...", OutputType.PROGRESS)
+    PrettyOutput.print("加载方法论...", OutputType.PROGRESS)
     user_jarvis_methodology = os.path.expanduser("~/.jarvis/methodology")
     if not os.path.exists(user_jarvis_methodology):
         return ""
@@ -565,7 +565,7 @@ def load_methodology(user_input: str) -> str:
             methodology_index.add_with_ids(vectors_array, np.array(ids)) # type: ignore
             query_embedding = _create_methodology_embedding(embedding_model, user_input)
             k = min(3, len(methodology_data))
-            PrettyOutput.print(f"Retrieving methodology...", OutputType.INFO)
+            PrettyOutput.print(f"检索方法论...", OutputType.INFO)
             distances, indices = methodology_index.search(
                 query_embedding.reshape(1, -1), k
             ) # type: ignore
@@ -590,9 +590,7 @@ def load_methodology(user_input: str) -> str:
         return make_methodology_prompt(data)
 
     except Exception as e:
-        PrettyOutput.print(f"Error loading methodology: {str(e)}", OutputType.ERROR)
-        import traceback
-        PrettyOutput.print(f"Error trace: {traceback.format_exc()}", OutputType.INFO)
+        PrettyOutput.print(f"加载方法论失败: {str(e)}", OutputType.ERROR)
         return ""
 
 
@@ -648,15 +646,15 @@ def init_gpu_config() -> Dict:
             torch.cuda.empty_cache()
             
             PrettyOutput.print(
-                f"GPU initialized: {torch.cuda.get_device_name(0)}\n"
-                f"Device Memory: {gpu_mem / 1024**3:.1f}GB\n"
-                f"Shared Memory: {config['shared_memory'] / 1024**3:.1f}GB", 
+                f"GPU已初始化: {torch.cuda.get_device_name(0)}\n"
+                f"设备内存: {gpu_mem / 1024**3:.1f}GB\n"
+                f"共享内存: {config['shared_memory'] / 1024**3:.1f}GB", 
                 output_type=OutputType.SUCCESS
             )
         else:
-            PrettyOutput.print("No GPU available, using CPU mode", output_type=OutputType.WARNING)
+            PrettyOutput.print("没有GPU可用, 使用CPU模式", output_type=OutputType.WARNING)
     except Exception as e:
-        PrettyOutput.print(f"GPU initialization failed: {str(e)}", output_type=OutputType.WARNING)
+        PrettyOutput.print(f"GPU初始化失败: {str(e)}", output_type=OutputType.WARNING)
         
     return config
 
@@ -677,7 +675,7 @@ def get_embedding_batch(embedding_model: Any, texts: List[str]) -> np.ndarray:
             all_vectors.extend(vectors)
         return np.vstack(all_vectors)
     except Exception as e:
-        PrettyOutput.print(f"Batch embedding failed: {str(e)}", OutputType.ERROR)
+        PrettyOutput.print(f"批量嵌入失败: {str(e)}", OutputType.ERROR)
         return np.zeros((0, embedding_model.get_sentence_embedding_dimension()), dtype=np.float32)
 
 
@@ -782,11 +780,11 @@ def get_context_token_count(text: str) -> int:
     try:
         # Use a fast tokenizer that's good at general text
         tokenizer = load_tokenizer()
-        chunks = split_text_into_chunks(text, 1024)
+        chunks = split_text_into_chunks(text, 512)
         return sum([len(tokenizer.encode(chunk)) for chunk in chunks])
         
     except Exception as e:
-        PrettyOutput.print(f"Error counting tokens: {str(e)}", OutputType.WARNING)
+        PrettyOutput.print(f"计算token失败: {str(e)}", OutputType.WARNING)
         # Fallback to rough character-based estimate
         return len(text) // 4  # Rough estimate of 4 chars per token