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

jarvis/jarvis_tools/search.py

@@ -1,6 +1,6 @@
 from typing import Dict, Any, List
 from jarvis.jarvis_platform.registry import PlatformRegistry
-from jarvis.utils import PrettyOutput, OutputType
+from jarvis.utils import PrettyOutput, OutputType, get_context_token_count, get_max_token_count
 from jarvis.jarvis_tools.read_webpage import WebpageTool
 from playwright.sync_api import sync_playwright
 from urllib.parse import quote
@@ -58,7 +58,7 @@ def bing_search(query):
             return summaries
             
     except Exception as error:
-        PrettyOutput.print(f"Search error: {str(error)}", OutputType.ERROR)
+        PrettyOutput.print(f"搜索错误：{str(error)}", OutputType.ERROR)
         return None
 
 class SearchTool:
@@ -106,28 +106,89 @@ class SearchTool:
                 })
             return formatted_results
         except Exception as e:
-            PrettyOutput.print(f"Search request failed: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"搜索请求失败：{str(e)}", OutputType.ERROR)
             return []
 
     def _extract_info(self, contents: List[str], question: str) -> str:
         """Use language model to extract key information from web content"""
-        prompt = f"""Please answer the question based on the following search results: {question}
+        try:
+            # Reserve tokens for prompt and response
+            max_tokens = get_max_token_count()
+            reserved_tokens = 2000  # Reserve tokens for prompt template and response
+            available_tokens = max_tokens - reserved_tokens
+            
+            # Split contents into batches
+            batches = []
+            current_batch = []
+            current_tokens = 0
+            
+            for content in contents:
+                content_tokens = get_context_token_count(content)
+                
+                # If adding this content would exceed limit, start new batch
+                if current_tokens + content_tokens > available_tokens:
+                    if current_batch:
+                        batches.append(current_batch)
+                    current_batch = [content]
+                    current_tokens = content_tokens
+                else:
+                    current_batch.append(content)
+                    current_tokens += content_tokens
+            
+            # Add final batch
+            if current_batch:
+                batches.append(current_batch)
 
-Search results content:
+            # Process each batch
+            batch_results = []
+            for i, batch in enumerate(batches, 1):
+                PrettyOutput.print(f"正在处理批次 {i}/{len(batches)}...", OutputType.PROGRESS)
+                
+                prompt = f"""Please analyze these search results to answer the question: {question}
+
+Search results content (Batch {i}/{len(batches)}):
 {'-' * 40}
-{''.join(contents)}
+{''.join(batch)}
 {'-' * 40}
 
-Please provide a concise and accurate answer, focusing on information directly related to the question. If there is no relevant information in the search results, please clearly state that.
-When answering, pay attention to:
-1. Maintain objectivity, providing information based solely on search results
-2. If there are conflicts between different sources, point out the differences
-3. Appropriately cite information sources
-4. If the information is incomplete or uncertain, please explain"""
+Please extract key information related to the question. Focus on:
+1. Relevant facts and details
+2. Maintaining objectivity
+3. Citing sources when appropriate
+4. Noting any uncertainties
+
+Format your response as a clear summary of findings from this batch."""
+
+                response = self.model.chat_until_success(prompt)
+                batch_results.append(response)
+
+            # If only one batch, return its result directly
+            if len(batch_results) == 1:
+                return batch_results[0]
+
+            # Synthesize results from all batches
+            batch_findings = '\n\n'.join(f'Batch {i+1}:\n{result}' for i, result in enumerate(batch_results))
+            separator = '-' * 40
+            
+            synthesis_prompt = f"""Please provide a comprehensive answer to the original question by synthesizing the findings from multiple batches of search results.
+
+Original Question: {question}
+
+Findings from each batch:
+{separator}
+{batch_findings}
+{separator}
+
+Please synthesize a final answer that:
+1. Combines key insights from all batches
+2. Resolves any contradictions between sources
+3. Maintains clear source attribution
+4. Acknowledges any remaining uncertainties
+5. Provides a coherent and complete response to the original question"""
+
+            final_response = self.model.chat_until_success(synthesis_prompt)
+            return final_response
 
-        try:
-            response = self.model.chat_until_success(prompt)
-            return response
         except Exception as e:
             return f"Information extraction failed: {str(e)}"
 
@@ -139,8 +200,8 @@ When answering, pay attention to:
             max_results = args.get("max_results", 3)
             
             # Print search information
-            PrettyOutput.print(f"Search query: {query}", OutputType.INFO)
-            PrettyOutput.print(f"Related question: {question}", OutputType.INFO)
+            PrettyOutput.print(f"搜索关键词: {query}", OutputType.INFO)
+            PrettyOutput.print(f"相关问题: {question}", OutputType.INFO)
             
             # Get search results
             results = self._search(query, max_results)
@@ -155,13 +216,13 @@ When answering, pay attention to:
             contents = []
             for i, result in enumerate(results, 1):
                 try:
-                    PrettyOutput.print(f"Reading result {i}/{len(results)}... {result['title']} - {result['href']}", OutputType.PROGRESS)
+                    PrettyOutput.print(f"正在读取结果 {i}/{len(results)}... {result['title']} - {result['href']}", OutputType.PROGRESS)
                     webpage_result = self.webpage_tool.execute({"url": result["href"]})
                     if webpage_result["success"]:
                         contents.append(f"\nSource {i}: {result['href']}\n")
                         contents.append(webpage_result["stdout"])
                 except Exception as e:
-                    PrettyOutput.print(f"Failed to read result {i}: {str(e)}", OutputType.WARNING)
+                    PrettyOutput.print(f"读取结果失败 {i}: {str(e)}", OutputType.WARNING)
                     continue
             
             if not contents:
@@ -172,7 +233,7 @@ When answering, pay attention to:
                 }
             
             # Extract information
-            PrettyOutput.print("Analyzing search results...", OutputType.PROGRESS)
+            PrettyOutput.print("正在分析搜索结果...", OutputType.PROGRESS)
             analysis = self._extract_info(contents, question)
             
             return {
@@ -200,15 +261,15 @@ def main():
     args = parser.parse_args()
     
     try:
-        PrettyOutput.print(f"Searching: {args.query}", OutputType.INFO)
+        PrettyOutput.print(f"搜索: {args.query}", OutputType.INFO)
         
         results = bing_search(args.query)
         
         if not results:
-            PrettyOutput.print("No search results found", OutputType.WARNING)
+            PrettyOutput.print("未找到搜索结果", OutputType.WARNING)
             sys.exit(1)
             
-        PrettyOutput.print(f"\nFound {len(results)} results:", OutputType.INFO)
+        PrettyOutput.print(f"\n找到 {len(results)} 个结果:", OutputType.INFO)
         
         for i, result in enumerate(results[:args.max], 1):
             output = []
@@ -217,16 +278,16 @@ def main():
                 output.append(f"{i}. {result['href']}")
             else:
                 output.append(f"{i}. {result['title']}")
-                output.append(f"Link: {result['href']}")
+                output.append(f"链接: {result['href']}")
                 if result['abstract']:
-                    output.append(f"Abstract: {result['abstract']}")
+                    output.append(f"摘要: {result['abstract']}")
             PrettyOutput.print("\n".join(output), OutputType.INFO)
                     
     except KeyboardInterrupt:
-        PrettyOutput.print("Search cancelled", OutputType.WARNING)
+        PrettyOutput.print("搜索已取消", OutputType.WARNING)
         sys.exit(1)
     except Exception as e:
-        PrettyOutput.print(f"Execution error: {str(e)}", OutputType.ERROR)
+        PrettyOutput.print(f"执行错误: {str(e)}", OutputType.ERROR)
         sys.exit(1)
 
 if __name__ == "__main__":

jarvis/jarvis_tools/select_code_files.py

@@ -33,7 +33,7 @@ class CodeFileSelecterTool:
             related_files = args.get("related_files", [])
             root_dir = args.get("root_dir", ".").strip()
 
-            PrettyOutput.print("Starting interactive file selection...", OutputType.INFO)
+            PrettyOutput.print("开始交互式文件选择...", OutputType.INFO)
 
             # Use file_select module to handle file selection
             selected_files = select_files(

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

@@ -165,18 +165,61 @@ class PrettyOutput:
 
     @staticmethod
     def print(text: str, output_type: OutputType, timestamp: bool = True, lang: Optional[str] = None, traceback: bool = False):
-        """Print formatted output using rich console"""
+        """Print formatted output using rich console with styling
+        
+        Args:
+            text: The text content to print
+            output_type: The type of output (affects styling)
+            timestamp: Whether to show timestamp
+            lang: Language for syntax highlighting
+            traceback: Whether to show traceback for errors
+        """
+        from rich.style import Style as RichStyle
+        
+        # Define styles for different output types
+        styles = {
+            OutputType.SYSTEM: RichStyle(color="cyan", bold=True),
+            OutputType.CODE: RichStyle(color="green"),
+            OutputType.RESULT: RichStyle(color="blue"),
+            OutputType.ERROR: RichStyle(color="red", bold=True),
+            OutputType.INFO: RichStyle(color="yellow"),
+            OutputType.PLANNING: RichStyle(color="magenta"),
+            OutputType.PROGRESS: RichStyle(color="white"),
+            OutputType.SUCCESS: RichStyle(color="green", bold=True),
+            OutputType.WARNING: RichStyle(color="yellow", bold=True),
+            OutputType.DEBUG: RichStyle(color="blue", dim=True),
+            OutputType.USER: RichStyle(color="green"),
+            OutputType.TOOL: RichStyle(color="yellow", italic=True)
+        }
+        
         # Get formatted header
         lang = lang if lang is not None else PrettyOutput._detect_language(text, default_lang='markdown')
         header = PrettyOutput._format("", output_type, timestamp)
-
-        content = Syntax(text, lang, theme="monokai")
-            
-        # Print panel with appropriate border style
-        border_style = "red" if output_type == OutputType.ERROR else output_type.value
-        console.print(Panel(content, border_style=border_style, title=header, title_align="left", highlight=True))
         
-        # Print stack trace for errors
+        # Create syntax highlighted content
+        content = Syntax(
+            text,
+            lang,
+            theme="monokai",
+            word_wrap=True,
+            background_color="default"
+        )
+        
+        # Create panel with styling
+        panel = Panel(
+            content,
+            style=styles[output_type],
+            border_style=styles[output_type],
+            title=header,
+            title_align="left",
+            padding=(1, 2),
+            highlight=True
+        )
+        
+        # Print panel
+        console.print(panel)
+        
+        # Print stack trace for errors if requested
         if traceback or output_type == OutputType.ERROR:
             console.print_exception()
 
@@ -322,7 +365,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 +391,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 +399,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 +409,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 +476,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 +527,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 +554,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 +608,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 +633,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 +689,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 +718,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 +823,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