jarvis-ai-assistant 0.1.131__py3-none-any.whl → 0.1.134__py3-none-any.whl

jarvis/jarvis_tools/search_web.py

@@ -1,319 +1,34 @@
-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
-from urllib.parse import quote
 
-from jarvis.jarvis_utils.config import get_max_token_count
-from jarvis.jarvis_utils.embedding import get_context_token_count
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
-def bing_search(query):
-    try:
-        with sync_playwright() as p:
-            # Set parameters when starting the browser
-            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
-            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
-            with yaspin(text="正在设置页面超时...", color="cyan") as spinner:
-                page.set_default_timeout(60000)
-                spinner.text = "页面超时设置完成"
-                spinner.ok("✅")
-            
-            # Visit search page
-            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
-            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
-            with yaspin(text="正在提取搜索结果...", color="cyan") as spinner:
-                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");
-                        
-                        if (linkEl) {
-                            results.push({
-                                title: titleEl.innerText.trim(),
-                                href: linkEl.href,
-                                abstract: abstractEl ? abstractEl.innerText.trim() : ""
-                            });
-                        }
-                    }
-                    return results;
-                }""")
-                spinner.text = "搜索结果提取完成"
-                spinner.ok("✅")
+import os
+import statistics
+from typing import Any, Dict
+from jarvis.jarvis_platform.registry import PlatformRegistry
 
-            with yaspin(text="正在关闭浏览器...", color="cyan") as spinner:
-                browser.close()
-                spinner.text = "浏览器关闭完成"
-                spinner.ok("✅")
-            return summaries
-            
-    except Exception as error:
-        PrettyOutput.print(f"搜索错误：{str(error)}", OutputType.ERROR)
-        return None
 
-class SearchTool:
+class SearchWebTool:
     name = "search_web"
-    description = "使用Bing搜索引擎搜索信息，并根据问题提取关键信息"
+    description = "搜索互联网上的信息"
     parameters = {
         "type": "object",
         "properties": {
-            "query": {
-                "type": "string",
-                "description": "搜索关键词"
-            },
-            "question": {
-                "type": "string",
-                "description": "要回答的具体问题，用于从搜索结果中提取相关信息"
-            },
-            "max_results": {
-                "type": "integer",
-                "description": "最大搜索结果数量",
-                "default": 3
-            }
-        },
-        "required": ["query", "question"]
+            "query": {"type": "string", "description": "具体的问题"}
+        }
     }
 
-    def __init__(self):
-        """Initialize the search tool, need to pass in the language model for information extraction"""
-        self.model = PlatformRegistry.get_global_platform_registry().get_normal_platform()
-        self.webpage_tool = WebpageTool()
-
-    def _search(self, query: str, max_results: int) -> List[Dict]:
-        """Execute search request"""
-        try:
-            results = bing_search(query)
-            if not results:
-                return []
-            
-            # Format search results
-            formatted_results = []
-            for result in results[:max_results]:
-                formatted_results.append({
-                    "title": result.get("title", ""),
-                    "href": result.get("href", ""),
-                    "body": result.get("abstract", "")
-                })
-            return formatted_results
-        except Exception as e:
-            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"""
-        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)
-
-            # Process each batch
-            batch_results = []
-            for i, batch in enumerate(batches, 1):
-                prompt = f"""请根据以下搜索结果回答以下问题：{question}
-
-搜索结果内容 (第 {i} 批/{len(batches)}):
-{'-' * 40}
-{''.join(batch)}
-{'-' * 40}
-
-请提取与问题相关的关键信息。重点关注：
-1. 相关事实和细节
-2. 保持客观性
-3. 在适当的时候引用来源
-4. 注明任何不确定性
-
-请将您的回答格式化为对本批次搜索结果的清晰总结。"""
-
-                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"""请通过综合多个批次的搜索结果，为原始问题提供一个全面的回答。
-
-原始问题: {question}
-
-各批次的发现:
-{separator}
-{batch_findings}
-{separator}
-
-请综合出一个最终答案，要求：
-1. 整合所有批次的关键见解
-2. 解决不同来源之间的矛盾
-3. 保持清晰的来源归属
-4. 承认任何剩余的不确定性
-5. 提供对原始问题的连贯完整的回答"""
-
-            final_response = self.model.chat_until_success(synthesis_prompt)
-            return final_response
-
-        except Exception as e:
-            return f"信息提取失败：{str(e)}"
-
-    def execute(self, args: Dict) -> Dict[str, Any]:
-        """Execute search and extract information"""
-        try:
-            query = args["query"]
-            question = args["question"]
-            max_results = args.get("max_results", 3)
-            
-            # Print search information
-            PrettyOutput.print(f"搜索关键词: {query}", OutputType.INFO)
-            PrettyOutput.print(f"相关问题: {question}", OutputType.INFO)
-            
-            # Get search results
-            results = self._search(query, max_results)
-            if not results:
-                return {
-                    "success": False,
-                    "stdout": "",
-                    "stderr": "No search results found"
-                }
-            
-            contents = []
-            for i, result in enumerate(results, 1):
-                try:
-                    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"读取结果失败 {i}: {str(e)}", OutputType.WARNING)
-                    continue
-            
-            if not contents:
-                return {
-                    "success": False,
-                    "stdout": "",
-                    "stderr": "No valid search results found"
-                }
-            
-            # Extract information
-            with yaspin(text="正在提取信息...", color="cyan") as spinner:   
-                analysis = self._extract_info(contents, question)
-                spinner.text = "信息提取完成"
-                spinner.ok("✅")
-            
-            return {
-                "success": True,
-                "stdout": f"Search analysis results:\n\n{analysis}",
-                "stderr": ""
-            }
-
-        except Exception as e:
-            return {
-                "success": False,
-                "stdout": "",
-                "stderr": f"Search failed: {str(e)}"
-            }
-
-def main():
-    """Command line directly run search tool"""
-    import argparse
-    import sys
-    
-    parser = argparse.ArgumentParser(description='Bing search tool')
-    parser.add_argument('query', help='Search keywords')
-    parser.add_argument('--max', type=int, default=5, help='Maximum number of results (default 5)')
-    parser.add_argument('--url-only', action='store_true', help='Only display URL')
-    args = parser.parse_args()
-    
-    try:
-        PrettyOutput.print(f"搜索: {args.query}", OutputType.INFO)
-        
-        results = bing_search(args.query)
-        
-        if not results:
-            PrettyOutput.print("未找到搜索结果", OutputType.WARNING)
-            sys.exit(1)
-            
-        PrettyOutput.print(f"\n找到 {len(results)} 个结果:", OutputType.INFO)
-        
-        for i, result in enumerate(results[:args.max], 1):
-            output = []
-            output.append(f"\n{'-'*50}")
-            if args.url_only:
-                output.append(f"{i}. {result['href']}")
-            else:
-                output.append(f"{i}. {result['title']}")
-                output.append(f"链接: {result['href']}")
-                if result['abstract']:
-                    output.append(f"摘要: {result['abstract']}")
-            PrettyOutput.print("\n".join(output), OutputType.INFO)
-                    
-    except KeyboardInterrupt:
-        PrettyOutput.print("搜索已取消", OutputType.WARNING)
-        sys.exit(1)
-    except Exception as e:
-        PrettyOutput.print(f"执行错误: {str(e)}", OutputType.ERROR)
-        sys.exit(1)
 
-if __name__ == "__main__":
-    main()
+    @staticmethod
+    def check() -> bool:
+        return os.getenv("YUANBAO_COOKIES", "") != "" and os.getenv("YUANBAO_AGENT_ID", "") != ""
+
+    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]: # type: ignore
+        query = args.get("query")
+        model = PlatformRegistry().create_platform("yuanbao")
+        model.set_suppress_output(False) # type: ignore
+        model.set_model_name("deep_seek") # type: ignore
+        return {
+            "stdout": model.chat_until_success(query), # type: ignore
+            "stderr": "",
+            "success": True,
+        }

jarvis/jarvis_tools/tool_generator.py

@@ -7,6 +7,7 @@ from typing import Dict, Any
 
 from yaspin import yaspin
 from jarvis.jarvis_platform.registry import PlatformRegistry
+from jarvis.jarvis_utils.utils import ct, ot
 
 class ToolGenerator:
     """工具生成器类，用于自动创建与Jarvis系统集成的新工具"""
@@ -41,7 +42,7 @@ class ToolGenerator:
             包含执行结果的字典，包含success、stdout和stderr字段
         """
         # 获取代码生成平台实例
-        model = PlatformRegistry.get_global_platform_registry().get_codegen_platform()
+        model = PlatformRegistry.get_global_platform_registry().get_normal_platform()
         
         try:
             tool_name = arguments["tool_name"]
@@ -112,8 +113,7 @@ class ToolGenerator:
         Returns:
             格式化后的提示字符串
         """
-        example_code = '''
-<TOOL>
+        example_code = ot("TOOL")+'''
 from typing import Dict, Any
 from jarvis.utils import OutputType, PrettyOutput
 from jarvis.jarvis_platform.registry import PlatformRegistry
@@ -148,7 +148,7 @@ class CustomTool:
         try:
             # 在此实现工具逻辑
             # 使用LLM
-            # model = PlatformRegistry.get_global_platform_registry().get_codegen_platform() 
+            # model = PlatformRegistry.get_global_platform_registry().get_normal_platform() 
             # result = model.chat_until_success(prompt)
 
             result = "工具执行结果"
@@ -163,8 +163,7 @@ class CustomTool:
                 "stdout": "",
                 "stderr": str(e)
             }
-</TOOL>
-'''
+''' + ct("TOOL")
 
         return f'''创建一个与Jarvis系统集成的Python工具类。请遵循以下要求：
 1. 类名: {tool_name.capitalize()}Tool
@@ -183,9 +182,9 @@ class CustomTool:
 8. 仅返回Python实现代码
 9. 代码应该是完整且可直接使用的
 10. 按照以下格式输出代码：
-<TOOL>
+{ot("TOOL")}
 {example_code}
-</TOOL>
+{ct("TOOL")}
 
 示例：
 {example_code}
@@ -199,8 +198,7 @@ class CustomTool:
         Returns:
             提取到的Python代码字符串
         """
-        # 查找第一个<TOOL>和</TOOL>标签之间的内容
-        sm = re.search(r'<TOOL>(.*?)</TOOL>', response, re.DOTALL)
+        sm = re.search(ot("TOOL")+r'(.*?)'+ct("TOOL"), response, re.DOTALL)
         if sm:
             return sm.group(1)
         return ""

jarvis/jarvis_utils/__init__.py

@@ -22,3 +22,4 @@ colorama.init()
 os.environ["TOKENIZERS_PARALLELISM"] = "false"
 # 安装rich traceback处理器以获得更好的错误信息
 install_rich_traceback()
+

jarvis/jarvis_utils/config.py

@@ -11,12 +11,12 @@ import os
 """
 def get_max_token_count() -> int:
     """
-    获取API请求的最大token数量。
+    获取模型允许的最大token数量。
     
-    返回：
-        int: 最大token数量，默认为131072（128k）
+    返回:
+        int: 模型能处理的最大token数量。
     """
-    return int(os.getenv('JARVIS_MAX_TOKEN_COUNT', '131072'))  # 默认128k
+    return int(os.getenv('JARVIS_MAX_TOKEN_COUNT', '64000'))  # 默认64k
     
 def get_thread_count() -> int:
     """
@@ -26,14 +26,6 @@ def get_thread_count() -> int:
         int: 线程数，默认为1
     """
     return int(os.getenv('JARVIS_THREAD_COUNT', '1'))  
-def dont_use_local_model() -> bool:
-    """
-    检查是否应避免使用本地模型。
-    
-    返回：
-        bool: 如果不使用本地模型则返回True，默认为False
-    """
-    return os.getenv('JARVIS_DONT_USE_LOCAL_MODEL', 'false') == 'true'
     
 def is_auto_complete() -> bool:
     """
@@ -44,30 +36,7 @@ def is_auto_complete() -> bool:
     """
     return os.getenv('JARVIS_AUTO_COMPLETE', 'false') == 'true'
     
-def is_use_methodology() -> bool:
-    """
-    检查是否应使用方法论。
-    
-    返回：
-        bool: 如果使用方法论则返回True，默认为True
-    """
-    return os.getenv('JARVIS_USE_METHODOLOGY', 'true') == 'true'
-def is_record_methodology() -> bool:
-    """
-    检查是否应记录方法论。
-    
-    返回：
-        bool: 如果记录方法论则返回True，默认为True
-    """
-    return os.getenv('JARVIS_RECORD_METHODOLOGY', 'true') == 'true'
-def is_need_summary() -> bool:
-    """
-    检查是否需要生成摘要。
-    
-    返回：
-        bool: 如果需要摘要则返回True，默认为True
-    """
-    return os.getenv('JARVIS_NEED_SUMMARY', 'true') == 'true'
+
 def get_min_paragraph_length() -> int:
     """
     获取文本处理的最小段落长度。
@@ -97,65 +66,36 @@ def get_normal_platform_name() -> str:
     获取正常操作的平台名称。
     
     返回：
-        str: 平台名称，默认为'kimi'
+        str: 平台名称，默认为'yuanbao'
     """
-    return os.getenv('JARVIS_PLATFORM', 'kimi')
+    return os.getenv('JARVIS_PLATFORM', 'yuanbao')
 def get_normal_model_name() -> str:
     """
     获取正常操作的模型名称。
     
     返回：
-        str: 模型名称，默认为'kimi'
+        str: 模型名称，默认为'deep_seek'
     """
-    return os.getenv('JARVIS_MODEL', 'kimi')
-def get_codegen_platform_name() -> str:
-    """
-    获取代码生成的平台名称。
-    
-    返回：
-        str: 平台名称，默认为'kimi'
-    """
-    return os.getenv('JARVIS_CODEGEN_PLATFORM', os.getenv('JARVIS_PLATFORM', 'kimi'))
-def get_codegen_model_name() -> str:
-    """
-    获取代码生成的模型名称。
-    
-    返回：
-        str: 模型名称，默认为'kimi'
-    """
-    return os.getenv('JARVIS_CODEGEN_MODEL', os.getenv('JARVIS_MODEL', 'kimi'))
+    return os.getenv('JARVIS_MODEL', 'deep_seek_v3')
+
+
 def get_thinking_platform_name() -> str:
     """
     获取思考操作的平台名称。
     
     返回：
-        str: 平台名称，默认为'kimi'
+        str: 平台名称，默认为'yuanbao'
     """
-    return os.getenv('JARVIS_THINKING_PLATFORM', os.getenv('JARVIS_PLATFORM', 'kimi'))
+    return os.getenv('JARVIS_THINKING_PLATFORM', os.getenv('JARVIS_PLATFORM', 'yuanbao'))
 def get_thinking_model_name() -> str:
     """
     获取思考操作的模型名称。
     
     返回：
-        str: 模型名称，默认为'kimi'
-    """
-    return os.getenv('JARVIS_THINKING_MODEL', os.getenv('JARVIS_MODEL', 'kimi'))
-def get_cheap_platform_name() -> str:
-    """
-    获取低成本操作的平台名称。
-    
-    返回：
-        str: 平台名称，默认为'kimi'
-    """
-    return os.getenv('JARVIS_CHEAP_PLATFORM', os.getenv('JARVIS_PLATFORM', 'kimi'))
-def get_cheap_model_name() -> str:
-    """
-    获取低成本操作的模型名称。
-    
-    返回：
-        str: 模型名称，默认为'kimi'
+        str: 模型名称，默认为'deep_seek'
     """
-    return os.getenv('JARVIS_CHEAP_MODEL', os.getenv('JARVIS_MODEL', 'kimi'))
+    return os.getenv('JARVIS_THINKING_MODEL', os.getenv('JARVIS_MODEL', 'deep_seek'))
+
 def is_execute_tool_confirm() -> bool:
     """
     检查工具执行是否需要确认。
@@ -172,3 +112,67 @@ def is_confirm_before_apply_patch() -> bool:
         bool: 如果需要确认则返回True，默认为False
     """
     return os.getenv('JARVIS_CONFIRM_BEFORE_APPLY_PATCH', 'false') == 'true'
+
+def get_rag_ignored_paths() -> list:
+    """
+    获取RAG索引时需要忽略的路径列表。
+    
+    首先尝试从.jarvis/rag_ignore.txt文件中读取，
+    如果该文件不存在，则返回默认忽略列表。
+    
+    返回：
+        list: 忽略路径的列表，默认包含常见忽略路径
+    """
+    # 默认忽略路径
+    default_ignored = [
+        '.git', 
+        '__pycache__', 
+        'node_modules', 
+        '.jarvis',
+        '.jarvis-*',
+        'target',
+        'venv',
+        'env',
+        '.env',
+        '.venv',
+        '.idea',
+        '.vscode',
+        'dist',
+        'build',
+        '*.pyc',
+        '*.pyo',
+        '*.so',
+        '*.o',
+        '*.a',
+        '*.pyd',
+        '*.dll',
+        '*.exe',
+        '*.bin',
+        '*.obj',
+        '*.out',
+        '*.jpg',
+        '*.jpeg',
+        '*.png',
+        '*.gif',
+        '*.tiff',
+        '*.pdf',
+        '*.zip',
+        '*.tar',
+        '*.tar.gz',
+        '*.gz',
+        '*.bz2',
+        '*.xz',
+        '*.rar'
+    ]
+    
+    # 尝试从配置文件中读取
+    try:
+        config_path = os.path.join('.jarvis', 'rag_ignore.txt')
+        if os.path.exists(config_path):
+            with open(config_path, 'r') as f:
+                custom_ignored = [line.strip() for line in f if line.strip() and not line.startswith('#')]
+                return custom_ignored
+    except Exception:
+        pass
+        
+    return default_ignored