jarvis-ai-assistant 0.1.125__py3-none-any.whl → 0.1.128__py3-none-any.whl

jarvis/jarvis_tools/search_web.py

@@ -1,4 +1,7 @@
 from typing import Dict, Any, List
+
+from regex import W
+from yaspin import yaspin
 from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_tools.read_webpage import WebpageTool
 from playwright.sync_api import sync_playwright
@@ -12,52 +15,72 @@ def bing_search(query):
     try:
         with sync_playwright() as p:
             # Set parameters when starting the browser
-            browser = p.chromium.launch(
-                headless=True,  # Headless mode
-                args=['--disable-gpu', '--no-sandbox', '--disable-dev-shm-usage']
-            )
+            with yaspin(text="正在启动浏览器...", color="cyan") as spinner:
+                browser = p.chromium.launch(
+                    headless=True,  # Headless mode
+                    args=['--disable-gpu', '--no-sandbox', '--disable-dev-shm-usage']
+                )
+                spinner.text = "浏览器启动完成"
+                spinner.ok("✅")
             
             # Create a new page and set timeout
-            page = browser.new_page(
-                user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36',
-                viewport={'width': 1920, 'height': 1080}
-            )
+            with yaspin(text="正在创建新页面...", color="cyan") as spinner:
+                page = browser.new_page(
+                    user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36',
+                    viewport={'width': 1920, 'height': 1080}
+                )
+                spinner.text = "新页面创建完成"
+                spinner.ok("✅")
             
             # Set page timeout
-            page.set_default_timeout(60000)
+            with yaspin(text="正在设置页面超时...", color="cyan") as spinner:
+                page.set_default_timeout(60000)
+                spinner.text = "页面超时设置完成"
+                spinner.ok("✅")
             
             # Visit search page
-            url = f"https://www.bing.com/search?q={quote(query)}&form=QBLH&sp=-1"
-            page.goto(url, wait_until="networkidle")
+            with yaspin(text=f"正在搜索 {query}...", color="cyan") as spinner:
+                url = f"https://www.bing.com/search?q={quote(query)}&form=QBLH&sp=-1"
+                page.goto(url, wait_until="networkidle")
+                spinner.text = "搜索完成"
+                spinner.ok("✅")
             
             # Wait for search results to load
-            page.wait_for_selector("#b_results", state="visible", timeout=30000)
-            
-            # Wait for a moment to ensure the results are fully loaded
-            page.wait_for_timeout(1000)
+            with yaspin(text="正在等待搜索结果加载...", color="cyan") as spinner:
+                page.wait_for_selector("#b_results", state="visible", timeout=30000)
+                # Wait for a moment to ensure the results are fully loaded
+                page.wait_for_timeout(1000)
+                spinner.text = "搜索结果加载完成"
+                spinner.ok("✅")
             
             # Extract search results
-            summaries = page.evaluate("""() => {
-                const results = [];
-                const elements = document.querySelectorAll("#b_results > .b_algo");
-                
-                for (const el of elements) {
-                    const titleEl = el.querySelector("h2");
-                    const linkEl = titleEl ? titleEl.querySelector("a") : null;
-                    const abstractEl = el.querySelector(".b_caption p");
+            with yaspin(text="正在提取搜索结果...", color="cyan") as spinner:
+                summaries = page.evaluate("""() => {
+                    const results = [];
+                    const elements = document.querySelectorAll("#b_results > .b_algo");
                     
-                    if (linkEl) {
-                        results.push({
-                            title: titleEl.innerText.trim(),
-                            href: linkEl.href,
-                            abstract: abstractEl ? abstractEl.innerText.trim() : ""
-                        });
+                    for (const el of elements) {
+                        const titleEl = el.querySelector("h2");
+                        const linkEl = titleEl ? titleEl.querySelector("a") : null;
+                        const abstractEl = el.querySelector(".b_caption p");
+                        
+                        if (linkEl) {
+                            results.push({
+                                title: titleEl.innerText.trim(),
+                                href: linkEl.href,
+                                abstract: abstractEl ? abstractEl.innerText.trim() : ""
+                            });
+                        }
                     }
-                }
-                return results;
-            }""")
-            
-            browser.close()
+                    return results;
+                }""")
+                spinner.text = "搜索结果提取完成"
+                spinner.ok("✅")
+
+            with yaspin(text="正在关闭浏览器...", color="cyan") as spinner:
+                browser.close()
+                spinner.text = "浏览器关闭完成"
+                spinner.ok("✅")
             return summaries
             
     except Exception as error:
@@ -66,21 +89,21 @@ def bing_search(query):
 
 class SearchTool:
     name = "search_web"
-    description = "Use Bing search engine to search for information, and extract key information based on the question"
+    description = "使用Bing搜索引擎搜索信息，并根据问题提取关键信息"
     parameters = {
         "type": "object",
         "properties": {
             "query": {
                 "type": "string",
-                "description": "Search keywords"
+                "description": "搜索关键词"
             },
             "question": {
                 "type": "string",
-                "description": "Specific question to answer, used to extract relevant information from search results"
+                "description": "要回答的具体问题，用于从搜索结果中提取相关信息"
             },
             "max_results": {
                 "type": "integer",
-                "description": "Maximum number of search results",
+                "description": "最大搜索结果数量",
                 "default": 3
             }
         },
@@ -235,8 +258,10 @@ Please synthesize a final answer that:
                 }
             
             # Extract information
-            PrettyOutput.print("正在分析搜索结果...", OutputType.PROGRESS)
-            analysis = self._extract_info(contents, question)
+            with yaspin(text="正在提取信息...", color="cyan") as spinner:   
+                analysis = self._extract_info(contents, question)
+                spinner.text = "信息提取完成"
+                spinner.ok("✅")
             
             return {
                 "success": True,
@@ -293,4 +318,4 @@ def main():
         sys.exit(1)
 
 if __name__ == "__main__":
-    main() 
+    main()

jarvis/jarvis_tools/select_code_files.py

@@ -6,7 +6,7 @@ from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 class CodeFileSelecterTool:
     name = "select_code_files"
-    description = "Select and manage code files for modification with interactive file selection"
+    description = "通过交互式文件选择工具选择和修改代码文件"
     parameters = {
         "type": "object",
         "properties": {
@@ -15,12 +15,12 @@ class CodeFileSelecterTool:
                 "items": {
                     "type": "string",
                 },
-                "description": "List of initially related files",
+                "description": "初始相关的文件列表",
                 "default": []
             },
             "root_dir": {
                 "type": "string",
-                "description": "Root directory of the codebase",
+                "description": "代码库的根目录",
                 "default": "."
             }
         },

jarvis/jarvis_tools/tool_generator.py

@@ -4,25 +4,27 @@ Tool Generator Tool - Automatically creates new tools using LLM
 from pathlib import Path
 import re
 from typing import Dict, Any
+
+from yaspin import yaspin
 from jarvis.jarvis_platform.registry import PlatformRegistry
 
 class ToolGenerator:
     name = "tool_generator"
-    description = "Generates new tools using LLM that integrate with the system"
+    description = "使用LLM自动生成与系统集成的新工具"
     parameters = {
         "type": "object",
         "properties": {
             "tool_name": {
                 "type": "string",
-                "description": "Name of the new tool"
+                "description": "新工具的名称"
             },
             "description": {
                 "type": "string", 
-                "description": "Description of the tool's purpose"
+                "description": "工具用途描述"
             },
             "input_spec": {
                 "type": "string",
-                "description": "Specification of required inputs and functionality"
+                "description": "所需输入和功能的规范说明"
             }
         },
         "required": ["tool_name", "description", "input_spec"]
@@ -39,33 +41,45 @@ class ToolGenerator:
             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)
+            with yaspin(text="正在生成工具...", color="cyan") as spinner:
+                prompt = self._create_prompt(tool_name, description, input_spec)
+                llm_response = model.chat_until_success(prompt)
+                spinner.text = "工具生成完成"
+                spinner.ok("✅")
             
             # 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"
-                }
+            with yaspin(text="正在提取工具实现...", color="cyan") as spinner:
+                implementation = self._extract_code(llm_response)
+                if not implementation:
+                    return {
+                        "success": False,
+                        "stdout": "",
+                        "stderr": "Could not extract valid Python code from LLM response"
+                    }
+                spinner.text = "工具实现提取完成"
+                spinner.ok("✅")
             
             # 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"
-                }
+            with yaspin(text="正在验证工具返回值格式...", color="cyan") as spinner:
+                if not self._validate_return_value_format(implementation):
+                    return {
+                        "success": False,
+                        "stdout": "",
+                        "stderr": "Generated tool does not follow required return value format"
+                    }
+                spinner.text = "工具返回值格式验证完成"
+                spinner.ok("✅")
             
             # 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)
+            with yaspin(text="正在保存工具...", color="cyan") as spinner:
+                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)
+                spinner.text = "工具保存完成"
+                spinner.ok("✅")
             
             return {
                 "success": True,
@@ -81,7 +95,7 @@ class ToolGenerator:
             }
     
     def _create_prompt(self, tool_name: str, description: str, input_spec: str) -> str:
-        """Create the LLM prompt for tool generation"""
+        """创建用于工具生成的LLM提示"""
         example_code = '''
 <TOOL>
 from typing import Dict, Any
@@ -89,24 +103,24 @@ 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
+    name = "工具名称"              # 调用时使用的工具名称
+    description = "工具描述"       # 工具用途
+    parameters = {                # 参数JSON Schema
         "type": "object",
         "properties": {
             "param1": {
                 "type": "string",
-                "description": "Parameter description"
+                "description": "参数描述"
             }
         },
         "required": ["param1"]
     }
 
     def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
-        """Execute the tool functionality
+        """执行工具功能
         
         Args:
-            args: Parameters passed to the tool
+            args: 传递给工具的参数
             
         Returns:
             {
@@ -116,12 +130,12 @@ class CustomTool:
             }
         """
         try:
-            # Implement the tool logic here
-            # Use LLM
+            # 在此实现工具逻辑
+            # 使用LLM
             # model = PlatformRegistry.get_global_platform_registry().get_codegen_platform() 
             # result = model.chat_until_success(prompt)
 
-            result = "Tool result"
+            result = "工具执行结果"
             return {
                 "success": True,
                 "stdout": result,
@@ -136,29 +150,28 @@ class CustomTool:
 </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:
+        return f'''创建一个与Jarvis系统集成的Python工具类。请遵循以下要求：
+1. 类名: {tool_name.capitalize()}Tool
+2. 描述: {description}
+3. 输入规范: {input_spec}
+4. 必须包含以下类属性：
+   - name: str (工具标识符)
+   - description: str (工具用途)
+   - parameters: dict (输入的JSON schema)
+5. 必须实现 execute(self, args: Dict) -> Dict 方法
+6. execute方法必须返回包含以下字段的字典：
+   - success: bool (指示操作是否成功)
+   - stdout: str (主要输出/结果)
+   - stderr: str (错误信息，如果有)
+7. 必须优雅地处理错误
+8. 仅返回Python实现代码
+9. 代码应该是完整且可直接使用的
+10. 按照以下格式输出代码：
 <TOOL>
 {example_code}
 </TOOL>
 
-Example:
+示例：
 {example_code}
 '''
     
@@ -179,4 +192,4 @@ Example:
             return False
         
         # Check for required fields in return statement
-        return all(field in code for field in required_fields)
+        return all(field in code for field in required_fields)

jarvis/jarvis_utils/methodology.py

@@ -42,18 +42,19 @@ def _create_methodology_embedding(embedding_model: Any, methodology_text: str) -
         return np.zeros(1536, dtype=np.float32)
 def make_methodology_prompt(data: Dict[str, str]) -> str:
     """
-    Generate a formatted prompt from methodology data.
+    从方法论数据生成格式化提示
     
     Args:
-        data: Dictionary of methodology data
+        data: 方法论数据字典
         
     Returns:
-        str: Formatted prompt string
+        str: 格式化后的提示字符串
     """
-    ret = """This is the standard methodology for handling previous problems, if the current task is similar, you can refer to it, if not,just ignore it:\n""" 
+    ret = """这是处理以往问题的标准方法论，如果当前任务类似，可以参考使用，如果不相关，请忽略：\n""" 
     for key, value in data.items():
-        ret += f"Problem: {key}\nMethodology: {value}\n"
+        ret += f"问题: {key}\n方法论: {value}\n"
     return ret
+
 def load_methodology(user_input: str) -> str:
     """
     Load methodology and build vector index for similarity search.
@@ -64,65 +65,82 @@ def load_methodology(user_input: str) -> str:
     Returns:
         str: Relevant methodology prompt or empty string if no methodology found
     """
-    PrettyOutput.print("加载方法论...", OutputType.PROGRESS)
+    from yaspin import yaspin
     user_jarvis_methodology = os.path.expanduser("~/.jarvis/methodology")
     if not os.path.exists(user_jarvis_methodology):
         return ""
     
     try:
-        with open(user_jarvis_methodology, "r", encoding="utf-8") as f:
-            data = yaml.safe_load(f)
-        if dont_use_local_model():
-            return make_methodology_prompt(data)
-        # Reset data structure
-        methodology_data: List[Dict[str, str]] = []
-        vectors: List[np.ndarray] = []
-        ids: List[int] = []
-        # Get embedding model
-        embedding_model = load_embedding_model()
+        with yaspin(text="加载方法论文件...", color="yellow") as spinner:
+            with open(user_jarvis_methodology, "r", encoding="utf-8") as f:
+                data = yaml.safe_load(f)
+            if dont_use_local_model():
+                spinner.text = "加载方法论文件完成"
+                spinner.ok("✅")
+                return make_methodology_prompt(data)
         
-        # Create test embedding to get correct dimension
-        test_embedding = _create_methodology_embedding(embedding_model, "test")
-        embedding_dimension = len(test_embedding)
-        # Create embedding vector for each methodology
-        for i, (key, value) in enumerate(data.items()):
-            methodology_text = f"{key}\n{value}"
-            embedding = _create_methodology_embedding(embedding_model, methodology_text)
-            vectors.append(embedding)
-            ids.append(i)
-            methodology_data.append({"key": key, "value": value})
-        if vectors:
-            vectors_array = np.vstack(vectors)
-            # Use correct dimension from test embedding
-            hnsw_index = faiss.IndexHNSWFlat(embedding_dimension, 16)
-            hnsw_index.hnsw.efConstruction = 40
-            hnsw_index.hnsw.efSearch = 16
-            methodology_index = faiss.IndexIDMap(hnsw_index)
-            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"检索方法论...", OutputType.INFO)
-            distances, indices = methodology_index.search(
-                query_embedding.reshape(1, -1), k
-            ) # type: ignore
-            relevant_methodologies = {}
-            output_lines = []
-            for dist, idx in zip(distances[0], indices[0]):
-                if idx >= 0:
-                    similarity = 1.0 / (1.0 + float(dist))
-                    methodology = methodology_data[idx]
-                    output_lines.append(
-                        f"Methodology '{methodology['key']}' similarity: {similarity:.3f}"
-                    )
-                    if similarity >= 0.5:
-                        relevant_methodologies[methodology["key"]] = methodology["value"]
+        with yaspin(text="初始化数据结构...", color="yellow") as spinner:
+            methodology_data: List[Dict[str, str]] = []
+            vectors: List[np.ndarray] = []
+            ids: List[int] = []
+            spinner.text = "初始化数据结构完成"
+            spinner.ok("✅")
+            
+            with yaspin(text="加载嵌入模型...", color="yellow") as spinner:
+                embedding_model = load_embedding_model()
+                spinner.text = "加载嵌入模型完成"
+                spinner.ok("✅")
+            
+            with yaspin(text="创建测试嵌入...", color="yellow") as spinner:
+                test_embedding = _create_methodology_embedding(embedding_model, "test")
+                embedding_dimension = len(test_embedding)
+                spinner.text = "创建测试嵌入完成"
+                spinner.ok("✅")
             
-            if output_lines:
-                PrettyOutput.print("\n".join(output_lines), OutputType.INFO)
-                    
-            if relevant_methodologies:
-                return make_methodology_prompt(relevant_methodologies)
-        return make_methodology_prompt(data)
+            with yaspin(text="处理方法论数据...", color="yellow") as spinner:
+                for i, (key, value) in enumerate(data.items()):
+                    methodology_text = f"{key}\n{value}"
+                    embedding = _create_methodology_embedding(embedding_model, methodology_text)
+                    vectors.append(embedding)
+                    ids.append(i)
+                    methodology_data.append({"key": key, "value": value})
+                spinner.text = "处理方法论数据完成"
+                spinner.ok("✅")
+            
+            if vectors:
+                with yaspin(text="构建索引...", color="yellow") as spinner:
+                    vectors_array = np.vstack(vectors)
+                    hnsw_index = faiss.IndexHNSWFlat(embedding_dimension, 16)
+                    hnsw_index.hnsw.efConstruction = 40
+                    hnsw_index.hnsw.efSearch = 16
+                    methodology_index = faiss.IndexIDMap(hnsw_index)
+                    methodology_index.add_with_ids(vectors_array, np.array(ids)) # type: ignore
+                    spinner.text = "构建索引完成"
+                    spinner.ok("✅")
+                
+                with yaspin(text="执行搜索...", color="yellow") as spinner:
+                    query_embedding = _create_methodology_embedding(embedding_model, user_input)
+                    k = min(3, len(methodology_data))
+                    distances, indices = methodology_index.search(
+                        query_embedding.reshape(1, -1), k
+                    ) # type: ignore
+                    spinner.text = "执行搜索完成"
+                    spinner.ok("✅")
+                
+                with yaspin(text="处理搜索结果...", color="yellow") as spinner:
+                    relevant_methodologies = {}
+                    for dist, idx in zip(distances[0], indices[0]):
+                        if idx >= 0:
+                            similarity = 1.0 / (1.0 + float(dist))
+                            methodology = methodology_data[idx]
+                            if similarity >= 0.5:
+                                relevant_methodologies[methodology["key"]] = methodology["value"]
+                    spinner.text = "处理搜索结果完成"
+                    spinner.ok("✅")
+
+                
+                if relevant_methodologies:
+                    return make_methodology_prompt(relevant_methodologies)
+            return make_methodology_prompt(data)
     except Exception as e:
-        PrettyOutput.print(f"加载方法论失败: {str(e)}", OutputType.ERROR)
-        return ""
+        return ""

jarvis/jarvis_utils/output.py

@@ -184,6 +184,7 @@ class PrettyOutput:
             highlight=True,
             box=HEAVY,
         )
+        console.print()
         console.print(panel)
         if traceback or output_type == OutputType.ERROR:
             console.print_exception()