jarvis-ai-assistant 0.1.148__py3-none-any.whl → 0.1.150__py3-none-any.whl

jarvis/jarvis_utils/file_processors.py

@@ -1,8 +1,3 @@
-from pathlib import Path
-import fitz  # PyMuPDF for PDF files
-from docx import Document as DocxDocument  # python-docx for DOCX files
-from pptx import Presentation
-import pandas as pd
 import unicodedata
 
 class FileProcessor:
@@ -84,260 +79,3 @@ class TextFileProcessor(FileProcessor):
 
         except Exception as e:
             raise Exception(f"Failed to read file: {str(e)}")
-
-class PDFProcessor(FileProcessor):
-    """PDF file processor"""
-    @staticmethod
-    def can_handle(file_path: str) -> bool:
-        return Path(file_path).suffix.lower() == '.pdf'
-
-    @staticmethod
-    def extract_text(file_path: str) -> str:
-        """提取PDF文件中的所有文本内容，包括页码、图片描述等"""
-        try:
-            text_parts = []
-            with fitz.open(file_path) as doc:  # type: ignore
-                # 添加文档信息
-                info = doc.metadata
-                if info:
-                    meta_text = []
-                    if info.get("title"):
-                        meta_text.append(f"标题: {info['title']}")
-                    if info.get("author"):
-                        meta_text.append(f"作者: {info['author']}")
-                    if info.get("subject"):
-                        meta_text.append(f"主题: {info['subject']}")
-                    if info.get("keywords"):
-                        meta_text.append(f"关键词: {info['keywords']}")
-                    
-                    if meta_text:
-                        text_parts.append("=== 文档信息 ===")
-                        text_parts.append("\n".join(meta_text))
-                
-                # 提取目录结构（如果有）
-                toc = doc.get_toc()  # type: ignore
-                if toc:
-                    text_parts.append("\n=== 目录结构 ===")
-                    for level, title, page in toc:
-                        indent = "  " * (level - 1)
-                        text_parts.append(f"{indent}- {title} (第{page}页)")
-                
-                # 处理各页内容
-                text_parts.append("\n=== 页面内容 ===")
-                for page_index in range(len(doc)):  # 使用范围遍历而不是直接枚举文档对象
-                    # 添加页码标记
-                    text_parts.append(f"\n--- 第{page_index+1}页 ---")
-                    
-                    # 获取页面
-                    page = doc[page_index]
-                    
-                    # 提取页面文本（包括结构信息）
-                    try:
-                        # 尝试使用结构化提取（保留段落和块结构）
-                        text = page.get_text("text")  # type: ignore
-                        text = text.strip()
-                        if text:
-                            text_parts.append(text)
-                    except Exception:
-                        # 如果结构化提取失败，回退到简单文本提取
-                        text = page.get_text()  # type: ignore
-                        if text.strip():
-                            text_parts.append(text.strip())
-                    
-                    # 提取图像信息（如果需要）
-                    # 注意：这可能会增加处理时间，可根据需要启用
-                    """
-                    image_list = page.get_images()
-                    if image_list:
-                        text_parts.append(f"本页包含 {len(image_list)} 个图像")
-                    """
-            
-            # 合并所有文本
-            return "\n".join(text_parts)
-        
-        except Exception as e:
-            # 处理可能的异常
-            return f"PDF处理错误: {str(e)}"
-
-class DocxProcessor(FileProcessor):
-    """DOCX file processor"""
-    @staticmethod
-    def can_handle(file_path: str) -> bool:
-        return Path(file_path).suffix.lower() == '.docx'
-
-    @staticmethod
-    def extract_text(file_path: str) -> str:
-        """提取 DOCX 文件中的所有文本内容，包括段落、表格、页眉页脚等"""
-        doc = DocxDocument(file_path)
-        full_text = []
-        
-        # 提取段落文本
-        for para in doc.paragraphs:
-            if para.text.strip():  # 跳过空段落
-                full_text.append(para.text)
-        
-        # 提取表格文本
-        for table in doc.tables:
-            for row in table.rows:
-                row_texts = []
-                for cell in row.cells:
-                    # 每个单元格可能包含多个段落
-                    cell_text = "\n".join([p.text for p in cell.paragraphs if p.text.strip()])
-                    if cell_text:
-                        row_texts.append(cell_text)
-                if row_texts:
-                    full_text.append(" | ".join(row_texts))
-        
-        # 提取页眉页脚（如果有节）
-        try:
-            for section in doc.sections:
-                # 提取页眉
-                if section.header:
-                    header_text = "\n".join([p.text for p in section.header.paragraphs if p.text.strip()])
-                    if header_text:
-                        full_text.append(f"页眉: {header_text}")
-                
-                # 提取页脚
-                if section.footer:
-                    footer_text = "\n".join([p.text for p in section.footer.paragraphs if p.text.strip()])
-                    if footer_text:
-                        full_text.append(f"页脚: {footer_text}")
-        except:
-            # 如果提取页眉页脚失败，忽略错误继续
-            pass
-        
-        # 合并所有文本
-        return "\n\n".join(full_text)
-
-class PPTProcessor(FileProcessor):
-    """PPT file processor"""
-    @staticmethod
-    def can_handle(file_path: str) -> bool:
-        return Path(file_path).suffix.lower() in ['.ppt', '.pptx']
-
-    @staticmethod
-    def extract_text(file_path: str) -> str:
-        """提取PPT文件中的所有文本内容，包括标题、文本框、备注等"""
-        prs = Presentation(file_path)
-        all_text = []
-        
-        # 遍历所有幻灯片
-        for slide_index, slide in enumerate(prs.slides, 1):
-            slide_text = []
-            
-            # 添加幻灯片编号
-            slide_text.append(f"=== 幻灯片 {slide_index} ===")
-            
-            # 提取幻灯片中所有形状的文本
-            for shape in slide.shapes:
-                # 提取带有文本的形状
-                try:
-                    if hasattr(shape, "text_frame") and shape.text_frame:  # type: ignore
-                        for paragraph in shape.text_frame.paragraphs:  # type: ignore
-                            text = paragraph.text.strip()
-                            if text:
-                                slide_text.append(text)
-                except AttributeError:
-                    pass
-                
-                # 提取表格内容
-                try:
-                    if hasattr(shape, "table") and shape.table:  # type: ignore
-                        for row in shape.table.rows:  # type: ignore
-                            row_texts = []
-                            for cell in row.cells:
-                                if hasattr(cell, "text_frame") and cell.text_frame:
-                                    cell_paragraphs = cell.text_frame.paragraphs  # type: ignore
-                                    cell_text = " ".join([p.text.strip() for p in cell_paragraphs if p.text.strip()])
-                                    if cell_text:
-                                        row_texts.append(cell_text)
-                            if row_texts:
-                                slide_text.append(" | ".join(row_texts))
-                except AttributeError:
-                    pass
-            
-            # 提取幻灯片备注
-            try:
-                if hasattr(slide, "has_notes_slide") and slide.has_notes_slide:
-                    notes_slide = slide.notes_slide
-                    if notes_slide and hasattr(notes_slide, "notes_text_frame") and notes_slide.notes_text_frame:
-                        notes_text = notes_slide.notes_text_frame.text.strip()  # type: ignore
-                        if notes_text:
-                            slide_text.append(f"备注: {notes_text}")
-            except AttributeError:
-                pass
-            
-            # 合并当前幻灯片的所有文本
-            if len(slide_text) > 1:  # 如果除了幻灯片编号外还有其他内容
-                all_text.append("\n".join(slide_text))
-        
-        # 返回所有幻灯片的文本内容
-        return "\n\n".join(all_text)
-
-class ExcelProcessor(FileProcessor):
-    """Excel file processor"""
-    @staticmethod
-    def can_handle(file_path: str) -> bool:
-        return Path(file_path).suffix.lower() in ['.xls', '.xlsx']
-
-    @staticmethod
-    def extract_text(file_path: str) -> str:
-        """提取 Excel 文件中的所有文本内容，包括多个工作表及格式化内容"""
-        try:
-            # 读取所有工作表
-            excel_file = pd.ExcelFile(file_path)
-            sheets_text = []
-            
-            # 处理每个工作表
-            for sheet_name in excel_file.sheet_names:
-                # 读取当前工作表
-                df = pd.read_excel(file_path, sheet_name=sheet_name)
-                
-                # 如果是空表格，跳过
-                if df.empty:
-                    continue
-                
-                # 添加工作表标题
-                sheet_text = [f"=== 工作表: {sheet_name} ==="]
-                
-                # 填充空单元格，避免NaN显示
-                df = df.fillna("")
-                
-                # 提取表格头信息
-                if not df.columns.empty:
-                    headers = [str(col) for col in df.columns]
-                    sheet_text.append("列标题: " + " | ".join(headers))
-                
-                # 尝试提取表格中可能的关键信息
-                # 1. 表格内容概述
-                row_count, col_count = df.shape
-                sheet_text.append(f"表格大小: {row_count}行 x {col_count}列")
-                
-                # 2. 表格数据，使用更友好的格式
-                try:
-                    # 转换数据框为字符串表示
-                    # 设置最大行数和列数，避免过大的表格
-                    max_rows = min(500, row_count)  # 最多显示500行
-                    if row_count > max_rows:
-                        sheet_text.append(f"注意: 表格太大，仅显示前{max_rows}行")
-                    
-                    # 将DataFrame转换为字符串表格
-                    table_str = df.head(max_rows).to_string(index=True, max_rows=max_rows, max_cols=None)
-                    sheet_text.append(table_str)
-                    
-                except Exception as e:
-                    sheet_text.append(f"表格数据提取错误: {str(e)}")
-                
-                # 合并当前工作表的文本
-                sheets_text.append("\n".join(sheet_text))
-            
-            # 如果没有提取到任何内容，返回一个提示信息
-            if not sheets_text:
-                return "Excel文件为空或无法提取内容"
-                
-            # 合并所有工作表的文本
-            return "\n\n".join(sheets_text)
-            
-        except Exception as e:
-            # 处理可能的异常，返回错误信息
-            return f"Excel文件处理错误: {str(e)}"

jarvis/jarvis_utils/git_utils.py

@@ -74,14 +74,16 @@ def get_commits_between(start_hash: str, end_hash: str) -> List[Tuple[str, str]]
             ['git', 'log', f'{start_hash}..{end_hash}', '--pretty=format:%H|%s'],
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
-            text=True
+            text=False  # 禁用自动文本解码
         )
         if result.returncode != 0:
-            PrettyOutput.print(f"获取commit历史失败: {result.stderr}", OutputType.ERROR)
+            error_msg = result.stderr.decode('utf-8', errors='replace')
+            PrettyOutput.print(f"获取commit历史失败: {error_msg}", OutputType.ERROR)
             return []
 
+        output = result.stdout.decode('utf-8', errors='replace')
         commits = []
-        for line in result.stdout.splitlines():
+        for line in output.splitlines():
             if '|' in line:
                 commit_hash, message = line.split('|', 1)
                 commits.append((commit_hash, message))
@@ -94,18 +96,27 @@ def get_latest_commit_hash() -> str:
     """获取当前Git仓库的最新提交哈希值
 
     返回：
-        str: 提交哈希值，如果不在Git仓库或发生错误则返回空字符串
+        str: 提交哈希值，如果不在Git仓库、空仓库或发生错误则返回空字符串
     """
     try:
+        # 首先检查是否存在HEAD引用
+        head_check = subprocess.run(
+            ['git', 'rev-parse', '--verify', 'HEAD'],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=False
+        )
+        if head_check.returncode != 0:
+            return ""  # 空仓库或无效HEAD
+
+        # 获取HEAD的完整哈希值
         result = subprocess.run(
             ['git', 'rev-parse', 'HEAD'],
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
-            text=True
+            text=False
         )
-        if result.returncode == 0:
-            return result.stdout.strip()
-        return ""
+        return result.stdout.decode('utf-8', errors='replace').strip() if result.returncode == 0 else ""
     except Exception:
         return ""
 def get_modified_line_ranges() -> Dict[str, Tuple[int, int]]:

jarvis/jarvis_utils/input.py

@@ -158,8 +158,14 @@ def get_multiline_input(tip: str) -> str:
         'prompt': 'ansicyan',
     })
     try:
+        from prompt_toolkit.history import FileHistory
+        from jarvis.jarvis_utils.config import get_data_dir
+        import os
+        # 获取数据目录路径
+        history_dir = get_data_dir()
+        # 初始化带历史记录的会话
         session = PromptSession(
-            history=None,
+            history=FileHistory(os.path.join(history_dir, 'multiline_input_history')),
             completer=FileCompleter(),
             key_bindings=bindings,
             complete_while_typing=True,

jarvis/jarvis_utils/methodology.py

@@ -11,7 +11,7 @@ import json
 import tempfile
 from typing import Dict, Optional
 
-from jarvis.jarvis_utils.config import INPUT_WINDOW_REVERSE_SIZE, get_max_input_token_count
+from jarvis.jarvis_utils.config import INPUT_WINDOW_REVERSE_SIZE, get_max_input_token_count, get_data_dir
 from jarvis.jarvis_utils.embedding import get_context_token_count
 from jarvis.jarvis_utils.output import PrettyOutput, OutputType
 from jarvis.jarvis_platform.registry import PlatformRegistry
@@ -23,7 +23,7 @@ def _get_methodology_directory() -> str:
     返回：
         str: 方法论目录的路径
     """
-    methodology_dir = os.path.expanduser("~/.jarvis/methodologies")
+    methodology_dir = os.path.join(get_data_dir(), "methodologies")
     if not os.path.exists(methodology_dir):
         try:
             os.makedirs(methodology_dir, exist_ok=True)

jarvis/jarvis_utils/output.py

@@ -11,7 +11,6 @@ from enum import Enum
 from datetime import datetime
 from typing import Optional
 from rich.panel import Panel
-from rich.box import HEAVY
 from rich.text import Text
 from rich.syntax import Syntax
 from rich.style import Style as RichStyle

jarvis/jarvis_utils/utils.py

@@ -2,24 +2,23 @@ import os
 import time
 import hashlib
 from pathlib import Path
-from typing import Union, List, Dict, Any, Callable, cast
-from bs4 import BeautifulSoup, Tag
-from jarvis.jarvis_utils.config import get_max_input_token_count
+from typing import List, Any, Callable
+from jarvis.jarvis_utils.config import get_max_input_token_count, get_data_dir
 from jarvis.jarvis_utils.embedding import get_context_token_count
 from jarvis.jarvis_utils.input import get_single_line_input
 from jarvis.jarvis_utils.output import PrettyOutput, OutputType
 def init_env() -> None:
-    """初始化环境变量从~/.jarvis/env文件
+    """初始化环境变量从jarvis_data/env文件
 
     功能：
-    1. 创建不存在的.jarvis目录
+    1. 创建不存在的jarvis_data目录
     2. 加载环境变量到os.environ
     3. 处理文件读取异常
     """
-    jarvis_dir = Path.home() / ".jarvis"
+    jarvis_dir = Path(get_data_dir())
     env_file = jarvis_dir / "env"
 
-    # Check if ~/.jarvis directory exists
+    # 检查jarvis_data目录是否存在
     if not jarvis_dir.exists():
         jarvis_dir.mkdir(parents=True)
     if env_file.exists():
@@ -53,7 +52,7 @@ def while_success(func: Callable[[], Any], sleep_time: float = 0.1) -> Any:
             time.sleep(sleep_time)
             continue
 def while_true(func: Callable[[], bool], sleep_time: float = 0.1) -> Any:
-    """Loop execution function, until the function returns True"""
+    """循环执行函数直到返回True"""
     while True:
         ret = func()
         if ret:
@@ -62,37 +61,37 @@ def while_true(func: Callable[[], bool], sleep_time: float = 0.1) -> Any:
         time.sleep(sleep_time)
     return ret
 def get_file_md5(filepath: str)->str:
-    """Calculate the MD5 hash of a file's content.
+    """计算文件内容的MD5哈希值
 
-    Args:
-        filepath: Path to the file to hash
+    参数:
+        filepath: 要计算哈希的文件路径
 
-    Returns:
-        str: MD5 hash of the file's content
+    返回:
+        str: 文件内容的MD5哈希值
     """
     return hashlib.md5(open(filepath, "rb").read(100*1024*1024)).hexdigest()
 def user_confirm(tip: str, default: bool = True) -> bool:
-    """Prompt the user for confirmation with a yes/no question.
+    """提示用户确认是/否问题
 
-    Args:
-        tip: The message to show to the user
-        default: The default response if user hits enter
+    参数:
+        tip: 显示给用户的消息
+        default: 用户直接回车时的默认响应
 
-    Returns:
-        bool: True if user confirmed, False otherwise
+    返回:
+        bool: 用户确认返回True，否则返回False
     """
     suffix = "[Y/n]" if default else "[y/N]"
     ret = get_single_line_input(f"{tip} {suffix}: ")
     return default if ret == "" else ret.lower() == "y"
 
 def get_file_line_count(filename: str) -> int:
-    """Count the number of lines in a file.
+    """计算文件中的行数
 
-    Args:
-        filename: Path to the file to count lines for
+    参数:
+        filename: 要计算行数的文件路径
 
-    Returns:
-        int: Number of lines in the file, 0 if file cannot be read
+    返回:
+        int: 文件中的行数，如果文件无法读取则返回0
     """
     try:
         return len(open(filename, "r", encoding="utf-8", errors="ignore").readlines())
@@ -153,200 +152,3 @@ def ct(tag_name: str) -> str:
     """
     return f"</{tag_name}>"
 
-
-def create_soup_element(content: Union[str, Tag, List[Any]]) -> List[Union[Tag, str]]:
-    """Safely create a BeautifulSoup element, ensuring it's treated as markup
-    
-    Args:
-        content: Input content to convert to BeautifulSoup elements
-    Returns:
-        List of BeautifulSoup elements or strings
-    """
-    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 [cast(Union[Tag, str], el) for el in soup_div.contents]
-        return []
-    elif isinstance(content, list):
-        return content
-    return [content]
-
-def extract_interactive_elements(html_content: str) -> List[Dict[str, Any]]:
-    """Extract all interactive elements from HTML content with their properties.
-    
-    Args:
-        html_content: HTML content to parse
-        
-    Returns:
-        List of dictionaries containing element properties:
-        - xpath: XPath of the element
-        - tag: HTML tag name
-        - text: Text content
-        - is_clickable: Whether element is clickable
-        - is_input: Whether element is an input field
-        - is_select: Whether element is a select dropdown
-    """
-    soup = BeautifulSoup(html_content, 'html.parser')
-    interactive_elements = []
-    
-    # Define interactive tags
-    clickable_tags = {'a', 'button', 'input', 'select', 'textarea'}
-    input_tags = {'input', 'textarea', 'select'}
-    
-    def get_xpath(element: Tag) -> str:
-        """Generate XPath for an element"""
-        components = []
-        current = element
-        
-        while current and current.name:
-            siblings = current.find_previous_siblings(current.name)
-            index = len(siblings) + 1
-            components.append(f"{current.name}[{index}]")
-            current = current.parent
-            
-        return "/".join(reversed(components))
-    
-    def process_element(element: Tag) -> None:
-        """Process a single element and add it to interactive_elements if it's interactive"""
-        tag_name = element.name.lower()
-        
-        # Skip non-interactive elements
-        if tag_name not in clickable_tags and not element.find_parent(clickable_tags):
-            return
-            
-        # Get element properties
-        element_info = {
-            'xpath': get_xpath(element),
-            'tag': tag_name,
-            'text': element.get_text().strip(),
-            'is_clickable': tag_name in clickable_tags or bool(element.find_parent('a')) or bool(element.find_parent('button')),
-            'is_input': tag_name in input_tags,
-            'is_select': tag_name == 'select'
-        }
-        
-        # Add additional properties for input elements
-        if element_info['is_input']:
-            element_info['input_type'] = element.get('type', 'text')
-            element_info['name'] = element.get('name', '')
-            element_info['value'] = element.get('value', '')
-            
-        # Add options for select elements
-        if element_info['is_select']:
-            element_info['options'] = [
-                {'value': opt.get('value', ''), 'text': opt.get_text().strip()}
-                for opt in element.find_all('option')
-                if isinstance(opt, Tag)
-            ]
-            
-        interactive_elements.append(element_info)
-    
-    # Process all elements
-    for element in soup.find_all():
-        if isinstance(element, Tag):
-            process_element(element)
-    
-    return interactive_elements
-
-def extract_display_elements(html_content: str) -> List[Dict[str, Any]]:
-    """Extract all display elements from HTML content with their properties.
-    
-    Args:
-        html_content: HTML content to parse
-        
-    Returns:
-        List of dictionaries containing element properties:
-        - xpath: XPath of the element
-        - tag: HTML tag name
-        - text: Text content
-        - heading_level: Heading level (1-6) if the element is a heading
-        - is_list: Whether the element is a list
-        - is_list_item: Whether the element is a list item
-        - is_table: Whether the element is a table
-        - is_table_cell: Whether the element is a table cell
-    """
-    soup = BeautifulSoup(html_content, 'html.parser')
-    display_elements = []
-    
-    # Define display tags
-    display_tags = {
-        'h1', 'h2', 'h3', 'h4', 'h5', 'h6',  # Headings
-        'p', 'div', 'span',                   # Text containers
-        'ul', 'ol', 'li',                     # Lists
-        'table', 'tr', 'td', 'th',            # Tables
-        'article', 'section', 'main',         # Content sections
-        'header', 'footer', 'nav',            # Layout sections
-        'aside', 'figure', 'figcaption'       # Side content
-    }
-    
-    # Define interactive tags to exclude
-    interactive_tags = {'a', 'button', 'input', 'select', 'textarea', 'form'}
-    
-    def get_xpath(element: Tag) -> str:
-        """Generate XPath for an element"""
-        components = []
-        current = element
-        
-        while current and current.name:
-            siblings = current.find_previous_siblings(current.name)
-            index = len(siblings) + 1
-            components.append(f"{current.name}[{index}]")
-            current = current.parent
-            
-        return "/".join(reversed(components))
-    
-    def process_element(element: Tag) -> None:
-        """Process a single element and add it to display_elements if it's a display element"""
-        tag_name = element.name.lower()
-        
-        # Skip non-display elements and interactive elements
-        if tag_name not in display_tags or element.find_parent(interactive_tags):
-            return
-            
-        # Get text content
-        text = element.get_text().strip()
-        if not text:  # Skip empty elements
-            return
-            
-        # Get element properties
-        element_info = {
-            'xpath': get_xpath(element),
-            'tag': tag_name,
-            'text': text,
-            'heading_level': int(tag_name[1]) if tag_name.startswith('h') and len(tag_name) == 2 else None,
-            'is_list': tag_name in {'ul', 'ol'},
-            'is_list_item': tag_name == 'li',
-            'is_table': tag_name == 'table',
-            'is_table_cell': tag_name in {'td', 'th'}
-        }
-        
-        # Add list-specific properties
-        if element_info['is_list']:
-            element_info['list_items'] = [
-                {'text': li.get_text().strip()}
-                for li in element.find_all('li')
-                if isinstance(li, Tag)
-            ]
-            
-        # Add table-specific properties
-        if element_info['is_table']:
-            element_info['table_rows'] = [
-                {
-                    'cells': [
-                        {'text': cell.get_text().strip(), 'is_header': cell.name == 'th'}
-                        for cell in row.find_all(['td', 'th'])
-                        if isinstance(cell, Tag)
-                    ]
-                }
-                for row in element.find_all('tr')
-                if isinstance(row, Tag)
-            ]
-            
-        display_elements.append(element_info)
-    
-    # Process all elements
-    for element in soup.find_all():
-        if isinstance(element, Tag):
-            process_element(element)
-    
-    return display_elements