jarvis-ai-assistant 0.1.110__py3-none-any.whl → 0.1.112__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/date_utils.py

@@ -0,0 +1,19 @@
+from datetime import datetime
+
+class DateValidator:
+    @staticmethod
+    def validate_iso_date(date_str: str) -> bool:
+        try:
+            datetime.fromisoformat(date_str)
+            return True
+        except ValueError:
+            return False
+
+    @staticmethod
+    def validate_date_range(start: str, end: str) -> bool:
+        try:
+            start_dt = datetime.fromisoformat(start)
+            end_dt = datetime.fromisoformat(end)
+            return start_dt <= end_dt
+        except ValueError:
+            return False

jarvis/utils.py

@@ -213,6 +213,8 @@ class FileCompleter(Completer):
     """Custom completer for file paths with fuzzy matching."""
     def __init__(self):
         self.path_completer = PathCompleter()
+        self.max_suggestions = 10  # 增加显示数量
+        self.min_score = 10  # 降低相似度阈值
         
     def get_completions(self, document: Document, complete_event):
         text = document.text_before_cursor
@@ -251,21 +253,26 @@ class FileCompleter(Completer):
         # If no input after @, show all files
         # Otherwise use fuzzy matching
         if not file_path:
-            scored_files = [(path, 100) for path in all_files]
+            scored_files = [(path, 100) for path in all_files[:self.max_suggestions]]
         else:
             scored_files = [
                 (path, fuzz.ratio(file_path.lower(), path.lower()))
                 for path in all_files
             ]
+            # Sort by score and take top results
             scored_files.sort(key=lambda x: x[1], reverse=True)
+            scored_files = scored_files[:self.max_suggestions]
         
         # Return completions for files
         for path, score in scored_files:
-            if not file_path or score > 30:  # Show all if no input, otherwise filter by score
+            if not file_path or score > self.min_score:
+                display_text = path
+                if file_path and score < 100:
+                    display_text = f"{path} ({score}%)"
                 completion = Completion(
                     text=path,
                     start_position=-len(file_path),
-                    display=f"{path}" if not file_path else f"{path} ({score}%)",
+                    display=display_text,
                     display_meta="File"
                 )
                 yield completion
@@ -315,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)
@@ -341,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):
@@ -349,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
 
@@ -359,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
 
@@ -376,6 +383,7 @@ def has_uncommitted_changes():
     working_changes = os.popen("git diff --exit-code").read().strip() != ""
     # Check staged changes
     staged_changes = os.popen("git diff --cached --exit-code").read().strip() != ""
+    os.system("git reset HEAD")
     return working_changes or staged_changes
 
 def load_embedding_model():
@@ -425,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
@@ -476,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
@@ -503,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 ""
@@ -557,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
@@ -582,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 ""
 
 
@@ -640,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
 
@@ -669,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)
 
 
@@ -685,9 +691,6 @@ def dont_use_local_model():
     
 def is_auto_complete() -> bool:
     return os.getenv('JARVIS_AUTO_COMPLETE', 'false') == 'true'
-
-def is_disable_codebase() -> bool:
-    return os.getenv('JARVIS_DISABLE_CODEBASE', 'false') == 'true'
     
 def is_use_methodology() -> bool:
     return os.getenv('JARVIS_USE_METHODOLOGY', 'true') == 'true'
@@ -731,6 +734,9 @@ def get_cheap_platform_name() -> str:
 def get_cheap_model_name() -> str:
     return os.getenv('JARVIS_CHEAP_MODEL', os.getenv('JARVIS_MODEL', 'kimi'))
 
+def is_execute_tool_confirm() -> bool:
+    return os.getenv('JARVIS_EXECUTE_TOOL_CONFIRM', 'false') == 'true'
+
 def split_text_into_chunks(text: str, max_length: int = 512) -> List[str]:
     """Split text into chunks with overlapping windows"""
     chunks = []
@@ -778,7 +784,7 @@ def get_context_token_count(text: str) -> int:
         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