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

jarvis/jarvis_tools/project_analyzer.py

@@ -0,0 +1,220 @@
+from typing import Dict, Any, List
+import os
+
+from jarvis.jarvis_agent import Agent
+from jarvis.jarvis_platform.registry import PlatformRegistry
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+
+
+class ProjectAnalyzerTool:
+    """
+    项目分析工具
+    使用agent分析项目结构、入口点、模块划分等信息
+    """
+    
+    name = "project_analyzer"
+    description = "分析项目结构、入口点、模块划分等信息，提供项目概览"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "root_dir": {
+                "type": "string",
+                "description": "项目根目录路径（可选）",
+                "default": "."
+            },
+            "focus_dirs": {
+                "type": "array",
+                "items": {
+                    "type": "string"
+                },
+                "description": "要重点分析的目录列表（可选）",
+                "default": []
+            },
+            "exclude_dirs": {
+                "type": "array",
+                "items": {
+                    "type": "string"
+                },
+                "description": "要排除的目录列表（可选）",
+                "default": []
+            },
+            "objective": {
+                "type": "string",
+                "description": "描述本次项目分析的目标和用途，例如'理解项目架构以便进行重构'或'寻找性能瓶颈'",
+                "default": ""
+            }
+        },
+        "required": []
+    }
+    
+    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        执行项目分析工具
+        
+        Args:
+            args: 包含参数的字典
+            
+        Returns:
+            包含执行结果的字典
+        """
+        # 存储原始目录
+        original_dir = os.getcwd()
+        
+        try:
+            # 解析参数
+            root_dir = args.get("root_dir", ".")
+            focus_dirs = args.get("focus_dirs", [])
+            exclude_dirs = args.get("exclude_dirs", [])
+            objective = args.get("objective", "")
+            
+            # 创建agent的system prompt
+            system_prompt = self._create_system_prompt(
+                root_dir, focus_dirs, exclude_dirs, objective
+            )
+            
+            # 创建agent的summary prompt
+            summary_prompt = self._create_summary_prompt(root_dir, objective)
+            
+            # 切换到根目录
+            os.chdir(root_dir)
+            
+            # 构建使用的工具
+            from jarvis.jarvis_tools.registry import ToolRegistry
+            tool_registry = ToolRegistry()
+            tool_registry.use_tools([
+                "execute_shell", 
+                "read_code", 
+                "find_symbol",
+                "function_analyzer",
+                "find_caller",
+                "file_analyzer",
+                "ask_codebase"
+            ])
+            
+            # 创建并运行agent
+            analyzer_agent = Agent(
+                system_prompt=system_prompt,
+                name=f"ProjectAnalyzer",
+                description=f"分析项目结构、模块划分和关键组件",
+                summary_prompt=summary_prompt,
+                platform=PlatformRegistry().get_codegen_platform(),
+                output_handler=[tool_registry],
+                need_summary=True,
+                is_sub_agent=True,
+                use_methodology=False,
+                record_methodology=False,
+                execute_tool_confirm=False,
+                auto_complete=True
+            )
+            
+            # 运行agent并获取结果
+            task_input = f"分析项目结构、入口点、模块划分等信息，提供项目概览"
+            result = analyzer_agent.run(task_input)
+            
+            return {
+                "success": True,
+                "stdout": result,
+                "stderr": ""
+            }
+                
+        except Exception as e:
+            PrettyOutput.print(str(e), OutputType.ERROR)
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"项目分析失败: {str(e)}"
+            }
+        finally:
+            # 恢复原始目录
+            os.chdir(original_dir)
+    
+    def _create_system_prompt(self, root_dir: str, focus_dirs: List[str], 
+                             exclude_dirs: List[str], objective: str) -> str:
+        """
+        创建Agent的system prompt
+        
+        Args:
+            root_dir: 项目根目录
+            focus_dirs: 重点分析的目录列表
+            exclude_dirs: 排除的目录列表
+            objective: 分析目标
+            
+        Returns:
+            系统提示文本
+        """
+        focus_dirs_str = ", ".join(focus_dirs) if focus_dirs else "整个项目"
+        exclude_dirs_str = ", ".join(exclude_dirs) if exclude_dirs else "无"
+            
+        objective_text = f"\n\n## 分析目标\n{objective}" if objective else "\n\n## 分析目标\n全面了解项目结构、模块划分和关键组件"
+        
+        return f"""# 项目架构分析专家
+
+## 任务描述
+对项目 `{root_dir}` 进行针对性分析，专注于分析目标所需的内容，生成有针对性、深入且有洞察力的项目分析报告。{objective_text}
+
+## 分析范围
+- 项目根目录: `{root_dir}`
+- 重点分析: {focus_dirs_str}
+- 排除目录: {exclude_dirs_str}
+
+## 分析策略
+1. 首先理解分析目标，确定你需要寻找什么信息
+2. 灵活采用适合目标的分析方法，不受预设分析框架的限制
+3. 有选择地探索项目，只关注与目标直接相关的部分
+4. 根据目标需要自行判断分析的深度和广度
+
+## 探索命令示例
+```bash
+# 获取项目文件结构
+find . -type f -not -path "*/\\.*" | sort
+
+# 查找可能的入口点
+find . -name "main.*" -o -name "app.*" -o -name "index.*"
+
+# 分析配置文件
+find . -name "*.json" -o -name "*.yaml" -o -name "*.toml" -o -name "*.ini" -o -name "*.conf"
+
+# 查找核心模块
+find . -name "core.*" -o -name "*core*" -o -name "main.*" -o -name "api.*"
+```
+
+## 分析工具使用
+- 使用`file_analyzer`分析关键文件结构和功能
+- 使用`find_symbol`定位和分析重要符号和函数
+- 使用`function_analyzer`深入理解复杂函数的实现
+- 使用`find_caller`追踪函数调用关系和依赖
+
+## 分析输出要求
+- 直接回应分析目标的关键问题
+- 提供与目标相关的深入洞察
+- 分析内容应直接服务于分析目标
+- 避免与目标无关的冗余信息
+- 使用具体代码路径和示例支持分析结论
+- 提供针对分析目标的具体建议和改进方向"""
+
+    def _create_summary_prompt(self, root_dir: str, objective: str) -> str:
+        """
+        创建Agent的summary prompt
+        
+        Args:
+            root_dir: 项目根目录
+            objective: 分析目标
+            
+        Returns:
+            总结提示文本
+        """
+        objective_text = f"\n\n## 具体分析目标\n{objective}" if objective else ""
+        
+        return f"""# 项目分析报告: `{root_dir}`{objective_text}
+
+## 报告要求
+生成一份完全以分析目标为导向的项目分析报告。不要遵循固定的报告模板，而是完全根据分析目标来组织内容：
+
+- 专注回答分析目标提出的问题
+- 只包含与分析目标直接相关的发现和洞察
+- 完全跳过与分析目标无关的内容，无需做全面分析
+- 分析深度应与目标的具体需求匹配
+- 使用具体的代码路径和示例支持你的观点
+- 以清晰的Markdown格式呈现，简洁明了
+
+在分析中保持灵活性，避免固定思维模式。你的任务不是提供全面的项目概览，而是直接解决分析目标中提出的具体问题。""" 

jarvis/jarvis_tools/read_code.py

@@ -7,7 +7,7 @@ from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 class ReadCodeTool:
     name = "read_code"
-    description = "用于读取代码文件并在每行前添加行号的工具"
+    description = "代码阅读与分析工具，用于读取源代码文件并添加行号，针对代码文件优化，提供更好的格式化输出和行号显示，适用于代码分析、审查和理解代码实现的场景"
     parameters = {
         "type": "object",
         "properties": {
@@ -29,6 +29,16 @@ class ReadCodeTool:
     }
 
     def _handle_single_file(self, filepath: str, start_line: int = 1, end_line: int = -1) -> Dict[str, Any]:
+        """处理单个文件的读取操作
+        
+        Args:
+            filepath (str): 文件路径
+            start_line (int): 起始行号，默认为1
+            end_line (int): 结束行号，默认为-1表示文件末尾
+            
+        Returns:
+            Dict[str, Any]: 包含成功状态、输出内容和错误信息的字典
+        """
         try:
             abs_path = os.path.abspath(filepath)
             with yaspin(text=f"正在读取文件: {abs_path}...", color="cyan") as spinner:
@@ -73,7 +83,7 @@ class ReadCodeTool:
                 # 添加行号并构建输出内容
                 selected_lines = lines[start_line-1:end_line]
                 numbered_content = "".join(
-                    [f"{i:4d} | {line}" 
+                    [f"{i:4d}:{line}" 
                      for i, line in enumerate(selected_lines, start=start_line)]
                 )
                 
@@ -86,6 +96,9 @@ class ReadCodeTool:
                 )
                 spinner.text = f"文件读取完成: {abs_path}"
                 spinner.ok("✅")
+
+                PrettyOutput.print(output, OutputType.SUCCESS)
+
                 return {
                     "success": True,
                     "stdout": output,
@@ -101,6 +114,14 @@ class ReadCodeTool:
             }
 
     def execute(self, args: Dict) -> Dict[str, Any]:
+        """执行代码读取操作
+        
+        Args:
+            args (Dict): 包含文件列表的参数字典
+            
+        Returns:
+            Dict[str, Any]: 包含成功状态、输出内容和错误信息的字典
+        """
         try:
             if "files" not in args or not isinstance(args["files"], list):
                 return {

jarvis/jarvis_tools/read_webpage.py

@@ -1,7 +1,8 @@
 from typing import Dict, Any
-import requests
-from bs4 import BeautifulSoup
-from yaspin import yaspin
+from playwright.sync_api import sync_playwright, TimeoutError as PlaywrightTimeoutError
+from bs4 import BeautifulSoup, Tag
+from urllib.parse import urlparse, urljoin
+import re
 
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
@@ -20,93 +21,206 @@ class WebpageTool:
     }
 
     def execute(self, args: Dict) -> Dict[str, Any]:
-        """Read webpage content"""
+        """Read webpage content using Playwright to handle JavaScript-rendered pages"""
         try:
-            url = args["url"].strip()   
+            url = args["url"].strip()
             
-            # Set request headers
-            headers = {
-                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
-            }
-            
-            # Send request
-            with yaspin(text="正在读取网页...", color="cyan") as spinner:
-                response = requests.get(url, headers=headers, timeout=10)
-                response.raise_for_status()
-                spinner.text = "网页读取完成"
-                spinner.ok("✅")
+            with sync_playwright() as p:
+                # Launch browser
+                browser = p.chromium.launch(
+                    headless=True,
+                    args=['--disable-gpu', '--no-sandbox', '--disable-dev-shm-usage']
+                )
                 
-            
-            # Use correct encoding
-
-            response.encoding = response.apparent_encoding
-            
-            # Parse HTML
-            with yaspin(text="正在解析网页...", color="cyan") as spinner:
-                soup = BeautifulSoup(response.text, 'html.parser')
-                spinner.text = "网页解析完成"
-                spinner.ok("✅")
-            
-            # Remove script and style tags
-            with yaspin(text="正在移除脚本和样式...", color="cyan") as spinner:
-                for script in soup(["script", "style"]):
-                    script.decompose()
-                spinner.text = "脚本和样式移除完成"
-                spinner.ok("✅")
-            
-            # Extract title
-            with yaspin(text="正在提取标题...", color="cyan") as spinner:
-                title = soup.title.string if soup.title else ""
-                title = title.strip() if title else "No title"
-                spinner.text = "标题提取完成"
-                spinner.ok("✅")
-            
-            with yaspin(text="正在提取文本和链接...", color="cyan") as spinner:
-                # Extract text and links
-                text_parts = []
-                links = []
+                # 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}
+                )
                 
-                # Process content and collect links
-                for element in soup.descendants:
-                    if element.name == 'a' and element.get('href'): # type: ignore
-                        href = element.get('href') # type: ignore
-                        text = element.get_text(strip=True)
-                        if text and href:
-                            links.append(f"[{text}]({href})")
-                    elif isinstance(element, str) and element.strip():
-                        text_parts.append(element.strip())
-                spinner.text = "文本和链接提取完成"
-                spinner.ok("✅")
-            
-            # Build output
-            with yaspin(text="正在构建输出...", color="cyan") as spinner:
+                # 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()
+                    
+                except Exception as e:
+                    raise Exception(f"Error navigating to page: {str(e)}")
+                finally:
+                    # Always close browser
+                    browser.close()
+                
+                # Parse with BeautifulSoup and convert to markdown
+                markdown_content = self._html_to_markdown(html_content, url)
+                
+                # Build output in markdown format
                 output = [
-                    f"Title: {title}",
-                    "",
-                    "Text content:",
-                    "\n".join(text_parts),
-                    "",
-                    "Links found:",
-                    "\n".join(links) if links else "No links found"
+                    f"# {title}",
+                    f"Url: {url}",
+                    markdown_content
                 ]
-                spinner.text = "输出构建完成"
-                spinner.ok("✅")
-            
-            return {
-                "success": True,
-                "stdout": "\n".join(output),
-                "stderr": ""
-            }
+                
+                return {
+                    "success": True,
+                    "stdout": "\n".join(output),
+                    "stderr": ""
+                }
 
-        except requests.RequestException as e:
-            return {
-                "success": False,
-                "stdout": "",
-                "stderr": f"Webpage request failed: {str(e)}"
-            }
         except Exception as e:
+            PrettyOutput.print(f"读取网页失败: {str(e)}", OutputType.ERROR)
             return {
                 "success": False,
                 "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()