jarvis-ai-assistant 0.1.138__py3-none-any.whl → 0.1.141__py3-none-any.whl

jarvis/jarvis_tools/file_operation.py

@@ -1,16 +1,23 @@
 from typing import Dict, Any
 import os
+from pathlib import Path
 
 from yaspin import yaspin
 
 from jarvis.jarvis_utils.globals import add_read_file_record
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+# 导入文件处理器
+from jarvis.jarvis_utils.file_processors import (
+    TextFileProcessor, PDFProcessor, DocxProcessor, 
+    PPTProcessor, ExcelProcessor
+)
 
 
 
 class FileOperationTool:
     name = "file_operation"
-    description = "文件批量操作工具，可批量读写多个文件，适用于需要同时处理多个文件的场景（读取配置文件、保存生成内容等），不提供代码分析功能"
+    description = "文件批量操作工具，可批量读写多个文件，支持文本、PDF、Word、Excel、PPT等格式，适用于需要同时处理多个文件的场景（读取配置文件、保存生成内容等）"
+    labels = ['file', 'io', 'batch']
     parameters = {
         "type": "object",
         "properties": {
@@ -35,12 +42,29 @@ class FileOperationTool:
         "required": ["operation", "files"]
     }
 
+    def _get_file_processor(self, file_path: str):
+        """获取适合处理指定文件的处理器"""
+        processors = [
+            PDFProcessor,    # PDF文件处理器
+            DocxProcessor,   # Word文档处理器
+            PPTProcessor,    # PowerPoint演示文稿处理器
+            ExcelProcessor,  # Excel表格处理器
+            TextFileProcessor  # 文本文件处理器(放在最后作为兜底)
+        ]
+        
+        for processor in processors:
+            if processor.can_handle(file_path):
+                return processor
+        
+        return None  # 如果没有合适的处理器，返回None
+    
     def _handle_single_file(self, operation: str, filepath: str, content: str = "",
                           start_line: int = 1, end_line: int = -1) -> Dict[str, Any]:
         """Handle operations for a single file"""
         try:
             abs_path = os.path.abspath(filepath)
             add_read_file_record(abs_path)
+            
             if operation == "read":
                 with yaspin(text=f"正在读取文件: {abs_path}...", color="cyan") as spinner:
                     if not os.path.exists(abs_path):
@@ -50,38 +74,82 @@ class FileOperationTool:
                             "stderr": f"文件不存在: {abs_path}"
                         }
 
-                    if os.path.getsize(abs_path) > 10 * 1024 * 1024:  # 10MB
+                    # 检查文件大小
+                    if os.path.getsize(abs_path) > 30 * 1024 * 1024:  # 30MB
                         return {
                             "success": False,
                             "stdout": "",
-                            "stderr": "File too large (>10MB)"
+                            "stderr": "文件过大 (>30MB)，无法处理"
                         }
-
-                    with open(abs_path, 'r', encoding='utf-8', errors="ignore") as f:
-                        lines = f.readlines()
-
-
-                    total_lines = len(lines)
-                    start_line = start_line if start_line >= 0 else total_lines + start_line + 1
-                    end_line = end_line if end_line >= 0 else total_lines + end_line + 1
-                    start_line = max(1, min(start_line, total_lines))
-                    end_line = max(1, min(end_line, total_lines))
-                    if end_line == -1:
-                        end_line = total_lines
-
-                    if start_line > end_line:
-                        spinner.text = "无效的行范围"
-                        spinner.fail("❌")
-                        error_msg = f"无效的行范围 [{start_line, end_line}] (文件总行数: {total_lines})"
+                    
+                    file_extension = Path(abs_path).suffix.lower()
+                    
+                    # 获取文件处理器
+                    processor = self._get_file_processor(abs_path)
+                    
+                    if processor is None:
                         return {
                             "success": False,
                             "stdout": "",
-                            "stderr": error_msg
+                            "stderr": f"不支持的文件类型: {file_extension}"
                         }
-
-                    content = "".join(lines[start_line - 1:end_line])
-                    output = f"\n文件: {abs_path}\n行: [{start_line}-{end_line}]\n{content}" + "\n\n"
-
+                    
+                    # 特殊处理纯文本文件，支持行范围选择
+                    if processor == TextFileProcessor:
+                        try:
+                            with open(abs_path, 'r', encoding='utf-8', errors="ignore") as f:
+                                lines = f.readlines()
+
+                            total_lines = len(lines)
+                            start_line = start_line if start_line >= 0 else total_lines + start_line + 1
+                            end_line = end_line if end_line >= 0 else total_lines + end_line + 1
+                            start_line = max(1, min(start_line, total_lines))
+                            end_line = max(1, min(end_line, total_lines))
+                            if end_line == -1:
+                                end_line = total_lines
+
+                            if start_line > end_line:
+                                spinner.text = "无效的行范围"
+                                spinner.fail("❌")
+                                error_msg = f"无效的行范围 [{start_line, end_line}] (文件总行数: {total_lines})"
+                                return {
+                                    "success": False,
+                                    "stdout": "",
+                                    "stderr": error_msg
+                                }
+
+                            content = "".join(lines[start_line - 1:end_line])
+                            file_info = f"\n文件: {abs_path} (文本文件)\n行: [{start_line}-{end_line}]/{total_lines}"
+                        except Exception as e:
+                            return {
+                                "success": False,
+                                "stdout": "",
+                                "stderr": f"读取文本文件失败: {str(e)}"
+                            }
+                    else:
+                        # 使用专用处理器来提取非文本文件的内容
+                        try:
+                            spinner.text = f"使用 {processor.__name__} 提取 {abs_path} 的内容..."
+                            content = processor.extract_text(abs_path)
+                            # 获取文件类型友好名称
+                            file_type_names = {
+                                PDFProcessor: "PDF文档",
+                                DocxProcessor: "Word文档",
+                                PPTProcessor: "PowerPoint演示文稿",
+                                ExcelProcessor: "Excel表格"
+                            }
+                            file_type = file_type_names.get(processor, file_extension)
+                            file_info = f"\n文件: {abs_path} ({file_type})"
+                        except Exception as e:
+                            return {
+                                "success": False,
+                                "stdout": "",
+                                "stderr": f"提取 {file_extension} 文件内容失败: {str(e)}"
+                            }
+                    
+                    # 构建输出信息
+                    output = f"{file_info}\n{content}" + "\n\n"
+                    
                     spinner.text = f"文件读取完成: {abs_path}"
                     spinner.ok("✅")
                     return {
@@ -98,13 +166,13 @@ class FileOperationTool:
                     spinner.ok("✅")
                     return {
                         "success": True,
-                        "stdout": f"Successfully wrote content to {abs_path}",
+                        "stdout": f"文件写入成功: {abs_path}",
                         "stderr": ""
                     }
             return {
                 "success": False,
                 "stdout": "",
-                "stderr": f"Unknown operation: {operation}"
+                "stderr": f"未知操作: {operation}"
             }
 
         except Exception as e:
@@ -112,7 +180,7 @@ class FileOperationTool:
             return {
                 "success": False,
                 "stdout": "",
-                "stderr": f"File operation failed for {abs_path}: {str(e)}"
+                "stderr": f"文件操作失败 {abs_path}: {str(e)}"
             }
 
     def execute(self, args: Dict) -> Dict[str, Any]:
@@ -134,7 +202,7 @@ class FileOperationTool:
                 return {
                     "success": False,
                     "stdout": "",
-                    "stderr": "files parameter is required and must be a list"
+                    "stderr": "files参数是必需的，且必须是一个列表"
                 }
 
             all_outputs = []
@@ -156,7 +224,7 @@ class FileOperationTool:
                 if result["success"]:
                     all_outputs.append(result["stdout"])
                 else:
-                    all_outputs.append(f"Error with {file_info['path']}: {result['stderr']}")
+                    all_outputs.append(f"处理文件 {file_info['path']} 时出错: {result['stderr']}")
                 success = success and result["success"]
 
             # Combine all outputs with separators
@@ -173,5 +241,5 @@ class FileOperationTool:
             return {
                 "success": False,
                 "stdout": "",
-                "stderr": f"File operation failed: {str(e)}"
+                "stderr": f"文件操作失败: {str(e)}"
             }

jarvis/jarvis_tools/{find_methodolopy.py → find_methodology.py}

@@ -7,6 +7,7 @@ from jarvis.jarvis_utils.methodology import load_methodology
 class FindMethodologyTool:
     name = "find_methodology"
     description = "方法论查找工具，用于在执行过程中查看历史方法论辅助决策"
+    labels = ['methodology', 'search', 'analysis']
     parameters = {
         "type": "object",
         "properties": {
@@ -18,7 +19,7 @@ class FindMethodologyTool:
         "required": ["query"]
     }
 
-    def execute(self, args: Dict) -> Dict[str, Any]:
+    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
         """执行方法论查找操作
 
         Args:

jarvis/jarvis_tools/lsp_get_diagnostics.py

@@ -8,6 +8,8 @@ class LSPGetDiagnosticsTool:
     name = "lsp_get_diagnostics"
     # 工具描述
     description = "Get diagnostic information (errors, warnings) from code files"
+    # 工具标签
+    labels = ['code', 'analysis', 'lsp']
     # 工具参数定义
     parameters = {
         "file_path": "Path to the file to analyze",

jarvis/jarvis_tools/methodology.py

@@ -1,8 +1,7 @@
 import os
 import json
-import glob
 import hashlib
-from typing import Dict, Optional, Any
+from typing import Dict, Any
 
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
@@ -13,6 +12,7 @@ class MethodologyTool:
 
     name = "methodology"
     description = "管理问题解决方法论，支持添加、更新和删除操作"
+    labels = ['analysis', 'planning']
     parameters = {
         "type": "object",
         "properties": {
@@ -23,7 +23,7 @@ class MethodologyTool:
             },
             "problem_type": {
                 "type": "string",
-                "description": "问题类型，例如：code_review, bug_fix 等"
+                "description": "问题类型，例如：部署开源项目、生成提交信息"
             },
             "content": {
                 "type": "string",
@@ -82,7 +82,7 @@ class MethodologyTool:
             return {
                 "success": False,
                 "stdout": "",
-                "stderr": "Missing required parameters: operation and problem_type"
+                "stderr": "缺少必要参数: operation和problem_type"
             }
 
         try:
@@ -95,14 +95,14 @@ class MethodologyTool:
                     os.remove(file_path)
                     return {
                         "success": True,
-                        "stdout": f"Deleted methodology for problem type '{problem_type}'",
+                        "stdout": f"已删除问题类型'{problem_type}'对应的方法论",
                         "stderr": ""
                     }
                 else:
                     return {
                         "success": False,
                         "stdout": "",
-                        "stderr": f"Methodology for problem type '{problem_type}' not found"
+                        "stderr": f"未找到问题类型'{problem_type}'对应的方法论"
                     }
 
             elif operation in ["update", "add"]:
@@ -110,7 +110,7 @@ class MethodologyTool:
                     return {
                         "success": False,
                         "stdout": "",
-                        "stderr": "Need to provide methodology content"
+                        "stderr": "需要提供方法论内容"
                     }
 
                 # 确保目录存在
@@ -128,10 +128,10 @@ class MethodologyTool:
 
                 PrettyOutput.print(f"方法论已保存到 {file_path}", OutputType.INFO)
 
-                action = "Updated" if os.path.exists(file_path) else "Added"
+                action = "更新" if os.path.exists(file_path) else "添加"
                 return {
                     "success": True,
-                    "stdout": f"{action} methodology for problem type '{problem_type}'",
+                    "stdout": f"{action}了问题类型'{problem_type}'对应的方法论",
                     "stderr": ""
                 }
 
@@ -139,13 +139,13 @@ class MethodologyTool:
                 return {
                     "success": False,
                     "stdout": "",
-                    "stderr": f"Unsupported operation type: {operation}"
+                    "stderr": f"不支持的操作类型: {operation}"
                 }
 
         except Exception as e:
             return {
                 "success": False,
                 "stdout": "",
-                "stderr": f"Execution failed: {str(e)}"
+                "stderr": f"执行失败: {str(e)}"
             }
 

jarvis/jarvis_tools/read_code.py

@@ -10,6 +10,8 @@ from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 class ReadCodeTool:
     name = "read_code"
     description = "代码阅读与分析工具，用于读取源代码文件并添加行号，针对代码文件优化，提供更好的格式化输出和行号显示，适用于代码分析、审查和理解代码实现的场景"
+    # 工具标签
+    labels = ['code', 'analysis', 'file']
     parameters = {
         "type": "object",
         "properties": {

jarvis/jarvis_tools/read_webpage.py

@@ -1,14 +1,12 @@
 from typing import Dict, Any
-from playwright.sync_api import sync_playwright, TimeoutError as PlaywrightTimeoutError
-from bs4 import BeautifulSoup, Tag
-from urllib.parse import urlparse, urljoin
-import re
-
+import os
+from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 class WebpageTool:
     name = "read_webpage"
     description = "读取网页内容，提取标题、文本和超链接"
+    labels = ['web', 'scraping']
     parameters = {
         "type": "object",
         "properties": {
@@ -20,79 +18,41 @@ class WebpageTool:
         "required": ["url"]
     }
 
-    def execute(self, args: Dict) -> Dict[str, Any]:
-        """Read webpage content using Playwright to handle JavaScript-rendered pages"""
+    def __init__(self):
+        if os.getenv("YUANBAO_COOKIES", "") != "" and os.getenv("YUANBAO_AGENT_ID", "") != "":
+            self.platform = "yuanbao"
+            self.model = "deep_seek"
+        elif os.getenv("KIMI_API_KEY", "") != "":
+            self.platform = "kimi"
+            self.model = "k1"
+        else:
+            self.platform = ""
+
+    @staticmethod
+    def check() -> bool:
+        return os.getenv("YUANBAO_COOKIES", "") != "" and os.getenv("YUANBAO_AGENT_ID", "") != "" or os.getenv("KIMI_API_KEY", "") != ""
+
+    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        """Read webpage content using Yuanbao model"""
         try:
             url = args["url"].strip()
+            
+            # Create Yuanbao model instance
+            model = PlatformRegistry().create_platform(self.platform)
+            model.set_suppress_output(False)  # type: ignore
+            model.set_model_name(self.model)  # type: ignore
 
-            with sync_playwright() as p:
-                # Launch browser
-                browser = p.chromium.launch(
-                    headless=True,
-                    args=['--disable-gpu', '--no-sandbox', '--disable-dev-shm-usage']
-                )
-
-                # Create a new page with appropriate settings
-                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}
-                )
-
-                # Set timeout to avoid long waits
-                page.set_default_timeout(30000)  # 30 seconds
-
-                try:
-                    # Navigate to URL and wait for page to load
-                    response = page.goto(url, wait_until="domcontentloaded")
-
-                    # Additional wait for network to be idle (with a timeout)
-                    try:
-                        page.wait_for_load_state("networkidle", timeout=10000)
-                    except PlaywrightTimeoutError:
-                        # Continue even if network doesn't become completely idle
-                        pass
-
-                    # Make sure we got a valid response
-                    if not response or response.status >= 400:
-                        raise Exception(f"Failed to load page: HTTP {response.status if response else 'No response'}")
-
-                    # Get page title safely
-                    title = "No title"
-                    try:
-                        title = page.title()
-                    except Exception:
-                        # Try to extract title from content if direct method fails
-                        try:
-                            title_element = page.query_selector("title")
-                            if title_element:
-                                title = title_element.text_content() or "No title"
-                        except Exception:
-                            pass
-
-                    # Get the HTML content after JavaScript execution
-                    html_content = page.content()
+            # Construct prompt for webpage reading
+            prompt = f"请帮我读取并总结这个网页的内容：{url}\n请以markdown格式输出，包含标题和主要内容。"
 
-                except Exception as e:
-                    raise Exception(f"Error navigating to page: {str(e)}")
-                finally:
-                    # Always close browser
-                    browser.close()
+            # Get response from Yuanbao model
+            response = model.chat_until_success(prompt)  # type: ignore
 
-                # Parse with BeautifulSoup and convert to markdown
-                markdown_content = self._html_to_markdown(html_content, url)
-
-                # Build output in markdown format
-                output = [
-                    f"# {title}",
-                    f"Url: {url}",
-                    markdown_content
-                ]
-
-                return {
-                    "success": True,
-                    "stdout": "\n".join(output),
-                    "stderr": ""
-                }
+            return {
+                "success": True,
+                "stdout": response,
+                "stderr": ""
+            }
 
         except Exception as e:
             PrettyOutput.print(f"读取网页失败: {str(e)}", OutputType.ERROR)
@@ -101,126 +61,3 @@ class WebpageTool:
                 "stdout": "",
                 "stderr": f"Failed to parse webpage: {str(e)}"
             }
-
-    def _create_soup_element(self, content):
-        """Safely create a BeautifulSoup element, ensuring it's treated as markup"""
-        if isinstance(content, str):
-            # Create a wrapper tag to ensure proper parsing
-            soup_div = BeautifulSoup(f"<div>{content}</div>", 'html.parser').div
-            if soup_div is not None:
-                return soup_div.contents
-            # Return an empty list if the div is None
-            return []
-        return content
-
-    def _html_to_markdown(self, html_content: str, base_url: str) -> str:
-        """Convert HTML to Markdown format preserving the content structure"""
-        soup = BeautifulSoup(html_content, 'html.parser')
-
-        # Remove unwanted elements
-        for element in soup(['script', 'style', 'meta', 'noscript', 'head']):
-            element.decompose()
-
-        # Process headings
-        for level in range(1, 7):
-            for heading in soup.find_all(f'h{level}'):
-                text = heading.get_text().strip()
-                heading_md = "\n\n" + "#" * level + " " + text + "\n\n"
-                new_element = self._create_soup_element(heading_md)
-                heading.replace_with(*new_element)
-
-        # Process paragraphs
-        for p in soup.find_all('p'):
-            text = p.get_text().strip()
-            if text:
-                new_element = self._create_soup_element("\n\n" + text + "\n\n")
-                p.replace_with(*new_element)
-
-        # Process unordered lists
-        for ul in soup.find_all('ul'):
-            items = []
-            for li in ul.find_all('li', recursive=False):
-                items.append("* " + li.get_text().strip())
-            new_element = self._create_soup_element("\n\n" + "\n".join(items) + "\n\n")
-            ul.replace_with(*new_element)
-
-        # Process ordered lists
-        for ol in soup.find_all('ol'):
-            items = []
-            for i, li in enumerate(ol.find_all('li', recursive=False), 1):
-                items.append(str(i) + ". " + li.get_text().strip())
-            new_element = self._create_soup_element("\n\n" + "\n".join(items) + "\n\n")
-            ol.replace_with(*new_element)
-
-        # Process links (first pass)
-        for a in soup.find_all('a', href=True):
-            try:
-                href = a['href']
-                text = a.get_text().strip()
-                if text and href:
-                    # Convert relative URLs to absolute
-                    if href.startswith('/') and not href.startswith('//'):
-                        href = urljoin(base_url, href)
-                    link_md = "[" + text + "](" + href + ")"
-                    new_element = self._create_soup_element(link_md)
-                    a.replace_with(*new_element)
-            except (KeyError, AttributeError):
-                continue
-
-        # Process images
-        for img in soup.find_all('img', src=True):
-            try:
-                src = img['src']
-                alt = img.get('alt', 'Image').strip()
-                # Convert relative URLs to absolute
-                if src.startswith('/') and not src.startswith('//'):
-                    src = urljoin(base_url, src)
-                img_md = "![" + alt + "](" + src + ")"
-                new_element = self._create_soup_element(img_md)
-                img.replace_with(*new_element)
-            except (KeyError, AttributeError, UnboundLocalError):
-                continue
-
-        # Process code blocks
-        for pre in soup.find_all('pre'):
-            code = pre.get_text().strip()
-            pre_md = "\n\n```\n" + code + "\n```\n\n"
-            new_element = self._create_soup_element(pre_md)
-            pre.replace_with(*new_element)
-
-        # Process inline code
-        for code in soup.find_all('code'):
-            text = code.get_text().strip()
-            code_md = "`" + text + "`"
-            new_element = self._create_soup_element(code_md)
-            code.replace_with(*new_element)
-
-        # Process line breaks
-        for br in soup.find_all('br'):
-            new_element = self._create_soup_element('\n')
-            br.replace_with(*new_element)
-
-        # Get the full text
-        markdown_text = soup.get_text()
-
-        # Clean up extra whitespace and line breaks
-        markdown_text = re.sub(r'\n{3,}', '\n\n', markdown_text)
-        markdown_text = re.sub(r'\s{2,}', ' ', markdown_text)
-
-        # Process links again (for any that might have been missed)
-        link_pattern = r'\[([^\]]+)\]\(([^)]+)\)'
-        all_links = re.findall(link_pattern, markdown_text)
-
-        # Add a section with all links at the end
-        if all_links:
-            link_section = ["", "## Links", ""]
-            seen_links = set()
-            for text, href in all_links:
-                link_entry = "[" + text + "](" + href + ")"
-                if link_entry not in seen_links:
-                    link_section.append(link_entry)
-                    seen_links.add(link_entry)
-
-            markdown_text += "\n\n" + "\n".join(link_section)
-
-        return markdown_text.strip()