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

jarvis/jarvis_tools/rag.py

@@ -1,7 +1,6 @@
 from typing import Dict, Any
 import os
 from jarvis.jarvis_rag.main import RAGTool as RAGCore
-from jarvis.jarvis_utils.config import dont_use_local_model
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 class RAGTool:
@@ -27,10 +26,6 @@ class RAGTool:
         "required": ["dir", "question"]
     }
 
-    @staticmethod
-    def check() -> bool:
-        return not dont_use_local_model()
-
     def __init__(self):
         """Initialize RAG tool"""
         self.rag_instances = {}  # Cache RAG instances for different directories

jarvis/jarvis_tools/read_code.py

@@ -90,7 +90,7 @@ class ReadCodeTool:
                 # 构建输出格式
                 output = (
                     f"\n🔍 文件: {abs_path}\n"
-                    f"📄 原始行号: {start_line}-{end_line} (共{end_line - start_line + 1}行) | 显示行号: 1-{len(selected_lines)}\n\n"
+                    f"📄 原始行号: {start_line}-{end_line} (共{total_lines}行) \n\n"
                     f"{numbered_content}\n"
                     f"{'='*80}\n"
                 )

jarvis/jarvis_tools/search_web.py

@@ -1,364 +1,34 @@
-from typing import Dict, Any, List
-import concurrent.futures
-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, get_thread_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("✅")
 
-            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
+import os
+import statistics
+from typing import Any, Dict
+from jarvis.jarvis_platform.registry import PlatformRegistry
+
 
-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": 10
-            }
-        },
-        "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"
-                }
-            
-            # Read webpages in parallel using ThreadPoolExecutor
-            contents = []
-            
-            # Print starting message
-            PrettyOutput.print(f"开始并行读取 {len(results)} 个网页结果...", OutputType.INFO)
-            
-            def fetch_webpage(result_info):
-                """Function to fetch a single webpage in a separate thread"""
-                idx, result = result_info
-                try:
-                    # Removed progress print here to avoid mixed output
-                    webpage_result = self.webpage_tool.execute({"url": result["href"]})
-                    if webpage_result["success"]:
-                        return idx, result, webpage_result["stdout"], True
-                    return idx, result, None, False
-                except Exception as e:
-                    return idx, result, str(e), False
-            
-            # Use ThreadPoolExecutor for parallel processing
-            processed_results = []
-            with yaspin(text="正在并行读取网页内容...", color="cyan") as spinner:
-                with concurrent.futures.ThreadPoolExecutor(max_workers=get_thread_count()) as executor:
-                    # Submit all webpage fetch tasks
-                    future_to_result = {
-                        executor.submit(fetch_webpage, (i, result)): i 
-                        for i, result in enumerate(results)
-                    }
-                    
-                    # Collect results as they complete
-                    for future in concurrent.futures.as_completed(future_to_result):
-                        processed_results.append(future.result())
-                        # Update spinner with current progress
-                        spinner.text = f"正在并行读取网页内容... ({len(processed_results)}/{len(results)})"
-                
-                spinner.text = "网页内容读取完成"
-                spinner.ok("✅")
-            
-            # Sort results by original index to maintain ordering
-            processed_results.sort(key=lambda x: x[0])
-            
-            # Print results in order and add to contents
-            PrettyOutput.section("搜索结果概览", OutputType.INFO)
-            
-            output = []
-            for idx, result, content, success in processed_results:
-                if success:
-                    output.append(f"✅ 读取结果 {idx+1}/{len(results)} 完成: {result['title']} - {result['href']}")
-                    contents.append(f"\nSource {idx+1}: {result['href']}\n")
-                    contents.append(content)
-                else:
-                    output.append(f"❌ 读取结果 {idx+1}/{len(results)} 失败: {result['title']} - {result['href']}")
-            
-            PrettyOutput.print("\n".join(output), OutputType.INFO)
-
-            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("✅")
-
-            output = f"分析结果:\n\n{analysis}"
-            PrettyOutput.print(output, OutputType.SUCCESS)
-            
-            return {
-                "success": True,
-                "stdout": output,
-                "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

@@ -42,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"]
@@ -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 = "工具执行结果"

jarvis/jarvis_utils/config.py

@@ -16,7 +16,7 @@ def get_max_token_count() -> int:
     返回:
         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'
-    """
-    return os.getenv('JARVIS_MODEL', 'kimi')
-def get_codegen_platform_name() -> str:
-    """
-    获取代码生成的平台名称。
-    
-    返回：
-        str: 平台名称，默认为'kimi'
+        str: 模型名称，默认为'deep_seek'
     """
-    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'
+        str: 模型名称，默认为'deep_seek'
     """
-    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'
-    """
-    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:
     """
     检查工具执行是否需要确认。

jarvis/jarvis_utils/methodology.py

@@ -18,7 +18,6 @@ import faiss
 from typing import Dict, Any, List, Tuple, Optional
 from jarvis.jarvis_utils.output import PrettyOutput, OutputType
 from jarvis.jarvis_utils.embedding import load_embedding_model
-from jarvis.jarvis_utils.config import dont_use_local_model
 
 # 全局缓存，避免重复计算嵌入向量
 _methodology_embeddings_cache = {}
@@ -375,13 +374,6 @@ def load_methodology(user_input: str) -> str:
         # 获取文件的修改时间戳组合哈希，用于检测文件是否被修改
         methodology_hash = _get_methodology_files_hash()
         
-        with yaspin(text="加载方法论文件...", color="yellow") as spinner:
-            data = _load_all_methodologies()
-            if dont_use_local_model():
-                spinner.text = "加载方法论文件完成"
-                spinner.ok("✅")
-                return make_methodology_prompt(data)
-        
         # 检查缓存的索引是否可用且方法论文件未被修改
         global _methodology_index_cache
         if _methodology_index_cache is None:
@@ -433,7 +425,6 @@ def load_methodology(user_input: str) -> str:
                 
                 if relevant_methodologies:
                     return make_methodology_prompt(relevant_methodologies)
-                return make_methodology_prompt(data)
         
         # 如果缓存无效，从头构建索引
         with yaspin(text="初始化数据结构...", color="yellow") as spinner:
@@ -453,6 +444,11 @@ def load_methodology(user_input: str) -> str:
                 embedding_dimension = len(test_embedding)
                 spinner.text = "创建测试嵌入完成"
                 spinner.ok("✅")
+
+            with yaspin(text="加载方法论文件...", color="yellow") as spinner:
+                data = _load_all_methodologies()
+                spinner.text = "加载方法论文件完成"
+                spinner.ok("✅")
             
             with yaspin(text="处理方法论数据...", color="yellow") as spinner:
                 for i, (key, value) in enumerate(data.items()):
@@ -483,7 +479,7 @@ def load_methodology(user_input: str) -> str:
                 
                 with yaspin(text="执行搜索...", color="yellow") as spinner:
                     query_embedding = _create_methodology_embedding(embedding_model, user_input)
-                    k = min(3, len(methodology_data))
+                    k = min(10, len(methodology_data))
                     distances, indices = methodology_index.search(
                         query_embedding.reshape(1, -1), k
                     ) # type: ignore
@@ -512,7 +508,8 @@ def load_methodology(user_input: str) -> str:
                 
                 if relevant_methodologies:
                     return make_methodology_prompt(relevant_methodologies)
-            return make_methodology_prompt(data)
+                
+        return make_methodology_prompt(data)
     except Exception as e:
         PrettyOutput.print(f"加载方法论失败: {str(e)}", OutputType.ERROR)
         return ""

jarvis/jarvis_utils/output.py

@@ -17,7 +17,7 @@ from rich.syntax import Syntax
 from rich.style import Style as RichStyle
 from pygments.lexers import guess_lexer
 from pygments.util import ClassNotFound
-from .globals import console, get_agent_list
+from jarvis.jarvis_utils.globals import console, get_agent_list
 class OutputType(Enum):
     """
     输出类型枚举，用于分类和样式化不同类型的消息。
@@ -186,7 +186,7 @@ class PrettyOutput:
         )
         console.print()
         console.print(panel)
-        if traceback:
+        if traceback or output_type == OutputType.ERROR:
             console.print_exception()
     @staticmethod
     def section(title: str, output_type: OutputType = OutputType.INFO):

jarvis/jarvis_utils/utils.py

@@ -2,7 +2,7 @@ import os
 import time
 import hashlib
 from pathlib import Path
-from typing import Dict, List
+from typing import Dict
 import psutil
 from jarvis.jarvis_utils.config import get_max_token_count
 from jarvis.jarvis_utils.embedding import get_context_token_count