Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.
Python agent-contextagent-memoryagent-pluginsagentic-ragcontext-databasedsh-pluginknowledge-basememorymemory-managementself-evolvingvector-database
feat: add markitdown-inspired file parsers (Word, PowerPoint, Excel, EPub, ZIP) (#128)
Zayn Jarvisc3042fec11d5
diff --git a/openviking/parse/parsers/__init__.py b/openviking/parse/parsers/__init__.pyindex 98e4ff942..75bf57e70 100644--- a/openviking/parse/parsers/__init__.py+++ b/openviking/parse/parsers/__init__.py@@ -3,18 +3,28 @@from .base_parser import BaseParserfrom .code import CodeRepositoryParser+from .epub import EPubParser+from .excel import ExcelParserfrom .html import HTMLParser, URLType, URLTypeDetectorfrom .markdown import MarkdownParserfrom .pdf import PDFParser+from .powerpoint import PowerPointParserfrom .text import TextParser+from .word import WordParser+from .zip_parser import ZipParser__all__ = ["BaseParser","CodeRepositoryParser",+ "EPubParser",+ "ExcelParser","HTMLParser","URLType","URLTypeDetector","MarkdownParser","PDFParser",+ "PowerPointParser","TextParser",+ "WordParser",+ "ZipParser",]diff --git a/openviking/parse/parsers/epub.py b/openviking/parse/parsers/epub.pynew file mode 100644index 000000000..c5c7e063d--- /dev/null+++ b/openviking/parse/parsers/epub.py@@ -0,0 +1,173 @@+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.+# SPDX-License-Identifier: Apache-2.0+"""+EPub (.epub) parser for OpenViking.++Converts EPub e-books to Markdown then parses using MarkdownParser.+Inspired by microsoft/markitdown approach.+"""++import html+import re+import zipfile+from pathlib import Path+from typing import List, Optional, Union++from openviking.parse.base import ParseResult+from openviking.parse.parsers.base_parser import BaseParser+from openviking_cli.utils.config.parser_config import ParserConfig+from openviking_cli.utils.logger import get_logger++logger = get_logger(__name__)+++class EPubParser(BaseParser):+ """+ EPub e-book parser for OpenViking.++ Supports: .epub++ Converts EPub e-books to Markdown using ebooklib (if available)+ or falls back to manual extraction, then delegates to MarkdownParser.+ """++ def __init__(self, config: Optional[ParserConfig] = None):+ """Initialize EPub parser."""+ from openviking.parse.parsers.markdown import MarkdownParser++ self._md_parser = MarkdownParser(config=config)+ self.config = config or ParserConfig()++ @property+ def supported_extensions(self) -> List[str]:+ return [".epub"]++ async def parse(self, source: Union[str, Path], instruction: str = "", **kwargs) -> ParseResult:+ """Parse EPub e-book from file path."""+ path = Path(source)++ if path.exists():+ markdown_content = self._convert_to_markdown(path)+ result = await self._md_parser.parse_content(+ markdown_content, source_path=str(path), instruction=instruction, **kwargs+ )+ else:+ result = await self._md_parser.parse_content(+ str(source), instruction=instruction, **kwargs+ )+ result.source_format = "epub"+ result.parser_name = "EPubParser"+ return result++ async def parse_content(+ self, content: str, source_path: Optional[str] = None, instruction: str = "", **kwargs+ ) -> ParseResult:+ """Parse content - delegates to MarkdownParser."""+ result = await self._md_parser.parse_content(content, source_path, **kwargs)+ result.source_format = "epub"+ result.parser_name = "EPubParser"+ return result++ def _convert_to_markdown(self, path: Path) -> str:+ """Convert EPub e-book to Markdown string."""+ # Try using ebooklib first+ try:+ import ebooklib+ from ebooklib import epub++ return self._convert_with_ebooklib(path, ebooklib, epub)+ except ImportError:+ pass++ # Fall back to manual extraction+ return self._convert_manual(path)++ def _convert_with_ebooklib(self, path: Path, ebooklib, epub) -> str:+ """Convert EPub using ebooklib."""+ book = epub.read_epub(path)+ markdown_parts = []++ title = self._get_metadata(book, "title")+ author = self._get_metadata(book, "creator")++ if title:+ markdown_parts.append(f"# {title}")+ if author:+ markdown_parts.append(f"**Author:** {author}")++ for item in book.get_items():+ if item.get_type() == ebooklib.ITEM_DOCUMENT:+ content = item.get_content().decode("utf-8", errors="ignore")+ md_content = self._html_to_markdown(content)+ if md_content.strip():+ markdown_parts.append(md_content)++ return "\n\n".join(markdown_parts)++ def _get_metadata(self, book, key: str) -> str:+ """Get metadata from EPub book."""+ try:+ metadata = book.get_metadata("DC", key)+ if metadata:+ return metadata[0][0]+ except Exception:+ pass+ return ""++ def _convert_manual(self, path: Path) -> str:+ """Convert EPub manually using zipfile and HTML parsing."""+ markdown_parts = []++ with zipfile.ZipFile(path, "r") as zf:+ html_files = [f for f in zf.namelist() if f.endswith((".html", ".xhtml", ".htm"))]++ for html_file in sorted(html_files):+ try:+ content = zf.read(html_file).decode("utf-8", errors="ignore")+ md_content = self._html_to_markdown(content)+ if md_content.strip():+ markdown_parts.append(md_content)+ except Exception as e:+ logger.warning(f"Failed to process {html_file}: {e}")++ return (+ "\n\n".join(markdown_parts)+ if markdown_parts+ else "# EPub Content\n\nUnable to extract content."+ )++ def _html_to_markdown(self, html_content: str) -> str:+ """Simple HTML to markdown conversion."""+ # Remove script and style tags+ html_content = re.sub(r"<script[^>]*>.*?</script>", "", html_content, flags=re.DOTALL)+ html_content = re.sub(r"<style[^>]*>.*?</style>", "", html_content, flags=re.DOTALL)++ # Convert headers+ html_content = re.sub(r"<h1[^>]*>(.*?)</h1>", r"# \1", html_content, flags=re.DOTALL)+ html_content = re.sub(r"<h2[^>]*>(.*?)</h2>", r"## \1", html_content, flags=re.DOTALL)+ html_content = re.sub(r"<h3[^>]*>(.*?)</h3>", r"### \1", html_content, flags=re.DOTALL)+ html_content = re.sub(r"<h4[^>]*>(.*?)</h4>", r"#### \1", html_content, flags=re.DOTALL)++ # Convert bold and italic+ html_content = re.sub(r"<strong>(.*?)</strong>", r"**\1**", html_content, flags=re.DOTALL)+ html_content = re.sub(r"<b>(.*?)</b>", r"**\1**", html_content, flags=re.DOTALL)+ html_content = re.sub(r"<em>(.*?)</em>", r"*\1*", html_content, flags=re.DOTALL)+ html_content = re.sub(r"<i>(.*?)</i>", r"*\1*", html_content, flags=re.DOTALL)++ # Convert paragraphs+ html_content = re.sub(r"<p[^>]*>(.*?)</p>", r"\1\n\n", html_content, flags=re.DOTALL)++ # Convert line breaks+ html_content = re.sub(r"<br\s*/?>", "\n", html_content)++ # Remove remaining HTML tags+ html_content = re.sub(r"<[^>]+>", "", html_content)++ # Unescape HTML entities+ html_content = html.unescape(html_content)++ # Normalize whitespace+ html_content = re.sub(r"\n\s*\n", "\n\n", html_content)+ html_content = re.sub(r"[ \t]+", " ", html_content)++ return html_content.strip()diff --git a/openviking/parse/parsers/excel.py b/openviking/parse/parsers/excel.pynew file mode 100644index 000000000..086dcc1c5--- /dev/null+++ b/openviking/parse/parsers/excel.py@@ -0,0 +1,131 @@+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.+# SPDX-License-Identifier: Apache-2.0+"""+Excel (.xlsx/.xls/.xlsm) parser for OpenViking.++Converts Excel spreadsheets to Markdown then parses using MarkdownParser.+Inspired by microsoft/markitdown approach.+"""++from pathlib import Path+from typing import List, Optional, Union++from openviking.parse.base import ParseResult+from openviking.parse.parsers.base_parser import BaseParser+from openviking_cli.utils.config.parser_config import ParserConfig+from openviking_cli.utils.logger import get_logger++logger = get_logger(__name__)+++class ExcelParser(BaseParser):+ """+ Excel spreadsheet parser for OpenViking.++ Supports: .xlsx, .xls, .xlsm++ Converts Excel spreadsheets to Markdown using openpyxl,+ then delegates to MarkdownParser for tree structure creation.+ """++ def __init__(self, config: Optional[ParserConfig] = None, max_rows_per_sheet: int = 1000):+ """+ Initialize Excel parser.++ Args:+ config: Parser configuration+ max_rows_per_sheet: Maximum rows to process per sheet (0 = unlimited)+ """+ from openviking.parse.parsers.markdown import MarkdownParser++ self._md_parser = MarkdownParser(config=config)+ self.config = config or ParserConfig()+ self.max_rows_per_sheet = max_rows_per_sheet++ @property+ def supported_extensions(self) -> List[str]:+ return [".xlsx", ".xls", ".xlsm"]++ async def parse(self, source: Union[str, Path], instruction: str = "", **kwargs) -> ParseResult:+ """Parse Excel spreadsheet from file path."""+ path = Path(source)++ if path.exists():+ import openpyxl++ markdown_content = self._convert_to_markdown(path, openpyxl)+ result = await self._md_parser.parse_content(+ markdown_content, source_path=str(path), instruction=instruction, **kwargs+ )+ else:+ result = await self._md_parser.parse_content(+ str(source), instruction=instruction, **kwargs+ )+ result.source_format = "xlsx"+ result.parser_name = "ExcelParser"+ return result++ async def parse_content(+ self, content: str, source_path: Optional[str] = None, instruction: str = "", **kwargs+ ) -> ParseResult:+ """Parse content - delegates to MarkdownParser."""+ result = await self._md_parser.parse_content(content, source_path, **kwargs)+ result.source_format = "xlsx"+ result.parser_name = "ExcelParser"+ return result++ def _convert_to_markdown(self, path: Path, openpyxl) -> str:+ """Convert Excel spreadsheet to Markdown string."""+ wb = openpyxl.load_workbook(path, data_only=True)++ markdown_parts = []+ markdown_parts.append(f"# {path.stem}")+ markdown_parts.append(f"**Sheets:** {len(wb.sheetnames)}")++ for sheet_name in wb.sheetnames:+ sheet = wb[sheet_name]+ sheet_content = self._convert_sheet(sheet, sheet_name)+ markdown_parts.append(sheet_content)++ return "\n\n".join(markdown_parts)++ def _convert_sheet(self, sheet, sheet_name: str) -> str:+ """Convert a single sheet to markdown."""+ parts = []+ parts.append(f"## Sheet: {sheet_name}")++ max_row = sheet.max_row+ max_col = sheet.max_column++ if max_row == 0 or max_col == 0:+ parts.append("*Empty sheet*")+ return "\n\n".join(parts)++ parts.append(f"**Dimensions:** {max_row} rows × {max_col} columns")++ rows_to_process = max_row+ if self.max_rows_per_sheet > 0:+ rows_to_process = min(max_row, self.max_rows_per_sheet)++ rows = []+ for _row_idx, row in enumerate(+ sheet.iter_rows(min_row=1, max_row=rows_to_process, values_only=True), 1+ ):+ row_data = []+ for cell in row:+ if cell is None:+ row_data.append("")+ else:+ row_data.append(str(cell))+ rows.append(row_data)++ if rows:+ from openviking.parse.base import format_table_to_markdown++ table_md = format_table_to_markdown(rows, has_header=True)+ parts.append(table_md)++ if self.max_rows_per_sheet > 0 and max_row > self.max_rows_per_sheet:+ parts.append(f"\n*... {max_row - self.max_rows_per_sheet} more rows truncated ...*")++ return "\n\n".join(parts)diff --git a/openviking/parse/parsers/powerpoint.py b/openviking/parse/parsers/powerpoint.pynew file mode 100644index 000000000..a33a1cfca--- /dev/null+++ b/openviking/parse/parsers/powerpoint.py@@ -0,0 +1,149 @@+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.+# SPDX-License-Identifier: Apache-2.0+"""+PowerPoint (.pptx) parser for OpenViking.++Converts PowerPoint presentations to Markdown then parses using MarkdownParser.+Inspired by microsoft/markitdown approach.+"""++from pathlib import Path+from typing import List, Optional, Union++from openviking.parse.base import ParseResult+from openviking.parse.parsers.base_parser import BaseParser+from openviking_cli.utils.config.parser_config import ParserConfig+from openviking_cli.utils.logger import get_logger++logger = get_logger(__name__)+++class PowerPointParser(BaseParser):+ """+ PowerPoint presentation parser for OpenViking.++ Supports: .pptx++ Converts PowerPoint presentations to Markdown using python-pptx,+ then delegates to MarkdownParser for tree structure creation.+ """++ def __init__(self, config: Optional[ParserConfig] = None, extract_notes: bool = False):+ """+ Initialize PowerPoint parser.++ Args:+ config: Parser configuration+ extract_notes: Whether to extract speaker notes+ """+ from openviking.parse.parsers.markdown import MarkdownParser++ self._md_parser = MarkdownParser(config=config)+ self.config = config or ParserConfig()+ self.extract_notes = extract_notes++ @property+ def supported_extensions(self) -> List[str]:+ return [".pptx"]++ async def parse(self, source: Union[str, Path], instruction: str = "", **kwargs) -> ParseResult:+ """Parse PowerPoint presentation from file path."""+ path = Path(source)++ if path.exists():+ import pptx++ markdown_content = self._convert_to_markdown(path, pptx)+ result = await self._md_parser.parse_content(+ markdown_content, source_path=str(path), instruction=instruction, **kwargs+ )+ else:+ result = await self._md_parser.parse_content(+ str(source), instruction=instruction, **kwargs+ )+ result.source_format = "pptx"+ result.parser_name = "PowerPointParser"+ return result++ async def parse_content(+ self, content: str, source_path: Optional[str] = None, instruction: str = "", **kwargs+ ) -> ParseResult:+ """Parse content - delegates to MarkdownParser."""+ result = await self._md_parser.parse_content(content, source_path, **kwargs)+ result.source_format = "pptx"+ result.parser_name = "PowerPointParser"+ return result++ def _convert_to_markdown(self, path: Path, pptx) -> str:+ """Convert PowerPoint presentation to Markdown string."""+ prs = pptx.Presentation(path)+ markdown_parts = []+ slide_count = len(prs.slides)++ for idx, slide in enumerate(prs.slides, 1):+ slide_parts = []+ slide_parts.append(f"## Slide {idx}/{slide_count}")++ title = self._extract_slide_title(slide)+ if title:+ slide_parts.append(f"### {title}")++ content = self._extract_slide_content(slide)+ if content:+ slide_parts.append(content)++ if self.extract_notes and slide.has_notes_slide:+ notes = slide.notes_slide.notes_text_frame.text.strip()+ if notes:+ slide_parts.append(f"**Notes:** {notes}")++ markdown_parts.append("\n\n".join(slide_parts))++ return "\n\n---\n\n".join(markdown_parts)++ def _extract_slide_title(self, slide) -> str:+ """Extract title from a slide."""+ from pptx.enum.shapes import PP_PLACEHOLDER++ for shape in slide.shapes:+ if shape.is_placeholder:+ ph_type = shape.placeholder_format.type+ if ph_type in (PP_PLACEHOLDER.TITLE, PP_PLACEHOLDER.CENTER_TITLE):+ return shape.text.strip()+ return ""++ def _extract_slide_content(self, slide) -> str:+ """Extract content from slide shapes."""+ from pptx.enum.shapes import PP_PLACEHOLDER++ content_parts = []++ for shape in slide.shapes:+ if shape.is_placeholder:+ ph_type = shape.placeholder_format.type+ if ph_type in (PP_PLACEHOLDER.TITLE, PP_PLACEHOLDER.CENTER_TITLE):+ continue++ if hasattr(shape, "text") and shape.text.strip():+ if shape.has_table:+ content_parts.append(self._convert_table(shape.table))+ else:+ text = shape.text.strip()+ if text:+ content_parts.append(text)++ return "\n\n".join(content_parts)++ def _convert_table(self, table) -> str:+ """Convert PowerPoint table to markdown format."""+ if not table.rows:+ return ""++ rows = []+ for row in table.rows:+ row_data = [cell.text.strip() for cell in row.cells]+ rows.append(row_data)++ from openviking.parse.base import format_table_to_markdown++ return format_table_to_markdown(rows, has_header=True)diff --git a/openviking/parse/parsers/text.py b/openviking/parse/parsers/text.pyindex 7b16165e7..7ad5b75cd 100644--- a/openviking/parse/parsers/text.py+++ b/openviking/parse/parsers/text.py@@ -37,4 +37,5 @@ class TextParser(BaseParser):"""Parse text content - delegates to MarkdownParser."""result = await self._md_parser.parse_content(content, source_path, **kwargs)result.source_format = "text"+ result.parser_name = "TextParser"return resultdiff --git a/openviking/parse/parsers/word.py b/openviking/parse/parsers/word.pynew file mode 100644index 000000000..35b0f426c--- /dev/null+++ b/openviking/parse/parsers/word.py@@ -0,0 +1,150 @@+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.+# SPDX-License-Identifier: Apache-2.0+"""+Word document (.docx) parser for OpenViking.++Converts Word documents to Markdown then parses using MarkdownParser.+Inspired by microsoft/markitdown approach.+"""++from pathlib import Path+from typing import List, Optional, Union++from openviking.parse.base import ParseResult+from openviking.parse.parsers.base_parser import BaseParser+from openviking_cli.utils.config.parser_config import ParserConfig+from openviking_cli.utils.logger import get_logger++logger = get_logger(__name__)+++class WordParser(BaseParser):+ """+ Word document parser for OpenViking.++ Supports: .docx++ Converts Word documents to Markdown using python-docx,+ then delegates to MarkdownParser for tree structure creation.+ """++ def __init__(self, config: Optional[ParserConfig] = None):+ """Initialize Word parser."""+ from openviking.parse.parsers.markdown import MarkdownParser++ self._md_parser = MarkdownParser(config=config)+ self.config = config or ParserConfig()++ @property+ def supported_extensions(self) -> List[str]:+ return [".docx"]++ async def parse(self, source: Union[str, Path], instruction: str = "", **kwargs) -> ParseResult:+ """Parse Word document from file path."""+ path = Path(source)++ if path.exists():+ import docx++ markdown_content = self._convert_to_markdown(path, docx)+ result = await self._md_parser.parse_content(+ markdown_content, source_path=str(path), instruction=instruction, **kwargs+ )+ else:+ result = await self._md_parser.parse_content(+ str(source), instruction=instruction, **kwargs+ )+ result.source_format = "docx"+ result.parser_name = "WordParser"+ return result++ async def parse_content(+ self, content: str, source_path: Optional[str] = None, instruction: str = "", **kwargs+ ) -> ParseResult:+ """Parse content - delegates to MarkdownParser."""+ result = await self._md_parser.parse_content(content, source_path, **kwargs)+ result.source_format = "docx"+ result.parser_name = "WordParser"+ return result++ def _convert_to_markdown(self, path: Path, docx) -> str:+ """Convert Word document to Markdown string.++ Iterates the document body in order so that tables appear in their+ original position rather than being appended at the end.+ """+ doc = docx.Document(path)+ markdown_parts = []++ # Map XML table elements to python-docx Table objects for O(1) lookup+ table_by_element = {table._tbl: table for table in doc.tables}++ # Walk the document body in order to preserve table positions+ from docx.oxml.ns import qn++ for child in doc.element.body:+ if child.tag == qn("w:p"):+ # It's a paragraph+ from docx.text.paragraph import Paragraph++ paragraph = Paragraph(child, doc)+ if not paragraph.text.strip():+ continue++ style_name = paragraph.style.name if paragraph.style else "Normal"++ if style_name.startswith("Heading"):+ level = self._extract_heading_level(style_name)+ markdown_parts.append(f"{'#' * level} {paragraph.text}")+ else:+ text = self._convert_formatted_text(paragraph)+ markdown_parts.append(text)++ elif child.tag == qn("w:tbl"):+ # It's a table+ if child in table_by_element:+ markdown_parts.append(self._convert_table(table_by_element[child]))++ return "\n\n".join(markdown_parts)++ def _extract_heading_level(self, style_name: str) -> int:+ """Extract heading level from style name."""+ try:+ if "Heading" in style_name:+ parts = style_name.split()+ for part in parts:+ if part.isdigit():+ return min(int(part), 6)+ except Exception:+ pass+ return 1++ def _convert_formatted_text(self, paragraph) -> str:+ """Convert paragraph with formatting to markdown."""+ text_parts = []+ for run in paragraph.runs:+ text = run.text+ if not text:+ continue+ if run.bold:+ text = f"**{text}**"+ if run.italic:+ text = f"*{text}*"+ if run.underline:+ text = f"<ins>{text}</ins>"+ text_parts.append(text)+ return "".join(text_parts)++ def _convert_table(self, table) -> str:+ """Convert Word table to markdown format."""+ if not table.rows:+ return ""++ rows = []+ for row in table.rows:+ row_data = [cell.text.strip() for cell in row.cells]+ rows.append(row_data)++ from openviking.parse.base import format_table_to_markdown++ return format_table_to_markdown(rows, has_header=True)diff --git a/openviking/parse/parsers/zip_parser.py b/openviking/parse/parsers/zip_parser.pynew file mode 100644index 000000000..ada2f8443--- /dev/null+++ b/openviking/parse/parsers/zip_parser.py@@ -0,0 +1,226 @@+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.+# SPDX-License-Identifier: Apache-2.0+"""+ZIP archive parser for OpenViking.++Lists and describes contents of ZIP files.+Converts to markdown and delegates to MarkdownParser.+"""++import zipfile+from datetime import datetime+from pathlib import Path+from typing import List, Optional, Union++from openviking.parse.base import ParseResult+from openviking.parse.parsers.base_parser import BaseParser+from openviking_cli.utils.config.parser_config import ParserConfig+from openviking_cli.utils.logger import get_logger++logger = get_logger(__name__)+++class ZipParser(BaseParser):+ """+ ZIP archive parser for OpenViking.++ Supports: .zip++ Features:+ - Lists all files in the archive+ - Shows file sizes and modification dates+ - Groups files by type/extension+ """++ def __init__(self, config: Optional[ParserConfig] = None):+ """Initialize ZIP parser."""+ from openviking.parse.parsers.markdown import MarkdownParser++ self._md_parser = MarkdownParser(config=config)+ self.config = config or ParserConfig()++ @property+ def supported_extensions(self) -> List[str]:+ return [".zip"]++ async def parse(self, source: Union[str, Path], instruction: str = "", **kwargs) -> ParseResult:+ """Parse from file path."""+ path = Path(source)++ if path.exists():+ markdown_content = self._convert_zip_to_markdown(path)+ result = await self._md_parser.parse_content(+ markdown_content,+ source_path=str(path),+ instruction=instruction,+ **kwargs,+ )+ else:+ # Treat as raw content string+ result = await self._md_parser.parse_content(+ str(source), instruction=instruction, **kwargs+ )+ result.source_format = "zip"+ result.parser_name = "ZipParser"+ return result++ async def parse_content(+ self, content: str, source_path: Optional[str] = None, instruction: str = "", **kwargs+ ) -> ParseResult:+ """Parse content - for zip, content should be a file path."""+ result = await self._md_parser.parse_content(content, source_path, **kwargs)+ result.source_format = "zip"+ result.parser_name = "ZipParser"+ return result++ def _convert_zip_to_markdown(self, path: Path) -> str:+ """+ Convert ZIP file information to markdown format.++ Args:+ path: Path to .zip file++ Returns:+ Markdown formatted string+ """+ try:+ with zipfile.ZipFile(path, "r") as zf:+ return self._process_zip_contents(zf, path)+ except zipfile.BadZipFile:+ raise ValueError(f"Invalid or corrupted ZIP file: {path}")+ except Exception as e:+ raise ValueError(f"Error reading ZIP file: {e}")++ def _process_zip_contents(self, zf: zipfile.ZipFile, path: Path) -> str:+ """Process ZIP file contents and return markdown."""+ md_parts = []++ # Title+ md_parts.append(f"# ZIP Archive: {path.name}")+ md_parts.append("")++ # Archive info+ md_parts.append("## Archive Information")+ md_parts.append("")+ md_parts.append(f"- **File:** {path.name}")+ md_parts.append(f"- **Total files:** {len(zf.namelist())}")+ md_parts.append(+ f"- **Comment:** {zf.comment.decode('utf-8', errors='ignore') if zf.comment else 'None'}"+ )+ md_parts.append("")++ # Group files by extension+ files_by_ext = self._group_files_by_extension(zf.namelist())++ # File listing by category+ md_parts.append("## Contents")+ md_parts.append("")++ # Summary table+ if files_by_ext:+ md_parts.append("### File Types Summary")+ md_parts.append("")+ md_parts.append("| Extension | Count |")+ md_parts.append("|-----------|-------|")+ for ext, files in sorted(files_by_ext.items(), key=lambda x: -len(x[1])):+ display_ext = ext if ext else "(no extension)"+ md_parts.append(f"| {display_ext} | {len(files)} |")+ md_parts.append("")++ # Detailed listing+ md_parts.append("### File List")+ md_parts.append("")++ # Create a table with file info+ md_parts.append("| File | Size | Modified |")+ md_parts.append("|------|------|----------|")++ for info in zf.infolist():+ # Skip directories+ if info.is_dir():+ continue++ filename = info.filename+ size = self._format_size(info.file_size)+ modified = self._format_datetime(info.date_time)++ # Escape pipe characters+ filename = filename.replace("|", "\\|")++ md_parts.append(f"| {filename} | {size} | {modified} |")++ md_parts.append("")++ # Directory structure+ md_parts.append("## Directory Structure")+ md_parts.append("")+ md_parts.append("```")+ md_parts.append(self._generate_tree_view(zf.namelist()))+ md_parts.append("```")++ return "\n".join(md_parts)++ def _group_files_by_extension(self, filenames: List[str]) -> dict:+ """Group files by their extension."""+ groups = {}+ for name in filenames:+ if name.endswith("/"): # Skip directories+ continue+ ext = Path(name).suffix.lower()+ if ext not in groups:+ groups[ext] = []+ groups[ext].append(name)+ return groups++ def _format_size(self, size: int) -> str:+ """Format file size in human-readable format."""+ for unit in ["B", "KB", "MB", "GB", "TB"]:+ if size < 1024.0:+ return f"{size:.1f} {unit}"+ size /= 1024.0+ return f"{size:.1f} PB"++ def _format_datetime(self, dt_tuple) -> str:+ """Format datetime tuple from ZIP info."""+ try:+ dt = datetime(*dt_tuple)+ return dt.strftime("%Y-%m-%d %H:%M")+ except:+ return "Unknown"++ def _generate_tree_view(self, filenames: List[str]) -> str:+ """Generate a tree-like view of the archive contents."""+ # Build a simple tree structure+ lines = []++ # Get unique directories+ dirs = set()+ for name in filenames:+ parts = name.split("/")+ for i in range(len(parts) - 1):+ dirs.add("/".join(parts[: i + 1]) + "/")++ # Sort all items+ all_items = sorted(set(filenames) | dirs)++ for item in all_items:+ # Calculate depth+ depth = item.count("/")+ if item.endswith("/"):+ depth -= 1++ # Create indentation+ indent = " " * depth++ # Get just the name part+ name = item.rstrip("/").split("/")[-1] if "/" in item else item++ # Add prefix for directories vs files+ if item.endswith("/"):+ prefix = "[dir] "+ else:+ prefix = ""++ lines.append(f"{indent}{prefix}{name}")++ return "\n".join(lines)diff --git a/openviking/parse/registry.py b/openviking/parse/registry.pyindex 4d5a69c27..dd35062c7 100644--- a/openviking/parse/registry.py+++ b/openviking/parse/registry.py@@ -12,13 +12,20 @@ from typing import TYPE_CHECKING, Callable, Dict, List, Optional, Unionfrom openviking.parse.base import ParseResultfrom openviking.parse.parsers.base_parser import BaseParser+from openviking.parse.parsers.epub import EPubParser+from openviking.parse.parsers.excel import ExcelParser# Import will be handled dynamically to avoid dependency issuesfrom openviking.parse.parsers.html import HTMLParserfrom openviking.parse.parsers.markdown import MarkdownParserfrom openviking.parse.parsers.pdf import PDFParser+from openviking.parse.parsers.powerpoint import PowerPointParserfrom openviking.parse.parsers.text import TextParser+# Import markitdown-inspired parsers+from openviking.parse.parsers.word import WordParser+from openviking.parse.parsers.zip_parser import ZipParser+if TYPE_CHECKING:from openviking.parse.custom import CustomParserProtocol@@ -49,6 +56,13 @@ class ParserRegistry:self.register("pdf", PDFParser())self.register("html", HTMLParser())+ # Register markitdown-inspired parsers (built-in)+ self.register("word", WordParser())+ self.register("powerpoint", PowerPointParser())+ self.register("excel", ExcelParser())+ self.register("epub", EPubParser())+ self.register("zip", ZipParser())+# Register code parser dynamicallytry:from openviking.parse.parsers.code import CodeRepositoryParserdiff --git a/pyproject.toml b/pyproject.tomlindex dd777a688..542afd293 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -38,6 +38,10 @@ dependencies = ["markdownify>=0.11.0","openai>=1.0.0","requests>=2.28.0",+ "python-docx>=1.0.0",+ "python-pptx>=1.0.0",+ "openpyxl>=3.0.0",+ "ebooklib>=0.18.0","json-repair>=0.25.0","apscheduler>=3.11.0","volcengine>=1.0.216",diff --git a/uv.lock b/uv.lockindex 0633c6084..dc6aa6417 100644--- a/uv.lock+++ b/uv.lock@@ -1,5 +1,5 @@version = 1-revision = 3+revision = 2requires-python = ">=3.10"resolution-markers = ["python_full_version >= '3.12'",@@ -541,6 +541,28 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/02/10/5da547df7a391dcde17f59520a231527b8571e6f46fc8efb02ccb370ab12/docutils-0.22.4-py3-none-any.whl", hash = "sha256:d0013f540772d1420576855455d050a2180186c91c15779301ac2ccb3eeb68de", size = 633196, upload-time = "2025-12-18T19:00:18.077Z" },]+[[package]]+name = "ebooklib"+version = "0.20"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "lxml" },+ { name = "six" },+]+sdist = { url = "https://files.pythonhosted.org/packages/77/85/322e8882a582d4b707220d1929cfb74c125f2ba513991edbce40dbc462de/ebooklib-0.20.tar.gz", hash = "sha256:35e2f9d7d39907be8d39ae2deb261b19848945903ae3dbb6577b187ead69e985", size = 127066, upload-time = "2025-10-26T20:56:20.968Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/bf/ee/aa015c5de8b0dc42a8e507eae8c2de5d1c0e068c896858fec6d502402ed6/ebooklib-0.20-py3-none-any.whl", hash = "sha256:fff5322517a37e31c972d27be7d982cc3928c16b3dcc5fd7e8f7c0f5d7bcf42b", size = 40995, upload-time = "2025-10-26T20:56:19.104Z" },+]++[[package]]+name = "et-xmlfile"+version = "2.0.0"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/d3/38/af70d7ab1ae9d4da450eeec1fa3918940a5fafb9055e934af8d6eb0c2313/et_xmlfile-2.0.0.tar.gz", hash = "sha256:dab3f4764309081ce75662649be815c4c9081e88f0837825f90fd28317d4da54", size = 17234, upload-time = "2024-10-25T17:25:40.039Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/c1/8b/5fe2cc11fee489817272089c4203e679c63b570a5aaeb18d852ae3cbba6a/et_xmlfile-2.0.0-py3-none-any.whl", hash = "sha256:7a91720bc756843502c3b7504c77b8fe44217c85c537d85037f0f536151b2caa", size = 18059, upload-time = "2024-10-25T17:25:39.051Z" },+]+[[package]]name = "exceptiongroup"version = "1.3.1"@@ -1230,15 +1252,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/d3/ac/686789b9145413f1a61878c407210e41bfdb097976864e0913078b24098c/myst_parser-5.0.0-py3-none-any.whl", hash = "sha256:ab31e516024918296e169139072b81592336f2fef55b8986aa31c9f04b5f7211", size = 84533, upload-time = "2026-01-15T09:08:16.788Z" },]-[[package]]-name = "nest-asyncio2"-version = "1.7.2"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/b4/73/731debf26e27e0a0323d7bda270dc2f634b398e38f040a09da1f4351d0aa/nest_asyncio2-1.7.2.tar.gz", hash = "sha256:1921d70b92cc4612c374928d081552efb59b83d91b2b789d935c665fa01729a8", size = 14743, upload-time = "2026-02-13T00:34:04.386Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/c5/3c/3179b85b0e1c3659f0369940200cd6d0fa900e6cefcc7ea0bc6dd0e29ffb/nest_asyncio2-1.7.2-py3-none-any.whl", hash = "sha256:f5dfa702f3f81f6a03857e9a19e2ba578c0946a4ad417b4c50a24d7ba641fe01", size = 7843, upload-time = "2026-02-13T00:34:02.691Z" },-]-[[package]]name = "openai"version = "2.20.0"@@ -1258,23 +1271,38 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/b5/a0/cf4297aa51bbc21e83ef0ac018947fa06aea8f2364aad7c96cbf148590e6/openai-2.20.0-py3-none-any.whl", hash = "sha256:38d989c4b1075cd1f76abc68364059d822327cf1a932531d429795f4fc18be99", size = 1098479, upload-time = "2026-02-10T19:02:52.157Z" },]+[[package]]+name = "openpyxl"+version = "3.1.5"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "et-xmlfile" },+]+sdist = { url = "https://files.pythonhosted.org/packages/3d/f9/88d94a75de065ea32619465d2f77b29a0469500e99012523b91cc4141cd1/openpyxl-3.1.5.tar.gz", hash = "sha256:cf0e3cf56142039133628b5acffe8ef0c12bc902d2aadd3e0fe5878dc08d1050", size = 186464, upload-time = "2024-06-28T14:03:44.161Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/c0/da/977ded879c29cbd04de313843e76868e6e13408a94ed6b987245dc7c8506/openpyxl-3.1.5-py2.py3-none-any.whl", hash = "sha256:5282c12b107bffeef825f4617dc029afaf41d0ea60823bbb665ef3079dc79de2", size = 250910, upload-time = "2024-06-28T14:03:41.161Z" },+]+[[package]]name = "openviking"source = { editable = "." }dependencies = [{ name = "apscheduler" },+ { name = "ebooklib" },{ name = "fastapi" },{ name = "httpx" },{ name = "jinja2" },{ name = "json-repair" },{ name = "markdownify" },- { name = "nest-asyncio2" },{ name = "openai" },+ { name = "openpyxl" },{ name = "pdfminer-six" },{ name = "pdfplumber" },{ name = "protobuf" },{ name = "pyagfs" },{ name = "pydantic" },+ { name = "python-docx" },+ { name = "python-pptx" },{ name = "pyyaml" },{ name = "readabilipy" },{ name = "requests" },@@ -1312,6 +1340,7 @@ test = [requires-dist = [{ name = "apscheduler", specifier = ">=3.11.0" },{ name = "boto3", marker = "extra == 'test'", specifier = ">=1.42.44" },+ { name = "ebooklib", specifier = ">=0.18.0" },{ name = "fastapi", specifier = ">=0.128.0" },{ name = "httpx", specifier = ">=0.25.0" },{ name = "jinja2", specifier = ">=3.1.6" },@@ -1319,8 +1348,8 @@ requires-dist = [{ name = "markdownify", specifier = ">=0.11.0" },{ name = "mypy", marker = "extra == 'dev'", specifier = ">=1.0.0" },{ name = "myst-parser", marker = "extra == 'doc'", specifier = ">=2.0.0" },- { name = "nest-asyncio2", specifier = ">=1.7.2" },{ name = "openai", specifier = ">=1.0.0" },+ { name = "openpyxl", specifier = ">=3.0.0" },{ name = "pdfminer-six", specifier = ">=20251230" },{ name = "pdfplumber", specifier = ">=0.10.0" },{ name = "protobuf", specifier = ">=6.33.5" },@@ -1329,6 +1358,8 @@ requires-dist = [{ name = "pytest", marker = "extra == 'test'", specifier = ">=7.0.0" },{ name = "pytest-asyncio", marker = "extra == 'test'", specifier = ">=0.21.0" },{ name = "pytest-cov", marker = "extra == 'test'", specifier = ">=4.0.0" },+ { name = "python-docx", specifier = ">=1.0.0" },+ { name = "python-pptx", specifier = ">=1.0.0" },{ name = "pyyaml", specifier = ">=6.0" },{ name = "readabilipy", specifier = ">=0.2.0" },{ name = "requests", specifier = ">=2.28.0" },@@ -1807,6 +1838,34 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" },]+[[package]]+name = "python-docx"+version = "1.2.0"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "lxml" },+ { name = "typing-extensions" },+]+sdist = { url = "https://files.pythonhosted.org/packages/a9/f7/eddfe33871520adab45aaa1a71f0402a2252050c14c7e3009446c8f4701c/python_docx-1.2.0.tar.gz", hash = "sha256:7bc9d7b7d8a69c9c02ca09216118c86552704edc23bac179283f2e38f86220ce", size = 5723256, upload-time = "2025-06-16T20:46:27.921Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/d0/00/1e03a4989fa5795da308cd774f05b704ace555a70f9bf9d3be057b680bcf/python_docx-1.2.0-py3-none-any.whl", hash = "sha256:3fd478f3250fbbbfd3b94fe1e985955737c145627498896a8a6bf81f4baf66c7", size = 252987, upload-time = "2025-06-16T20:46:22.506Z" },+]++[[package]]+name = "python-pptx"+version = "1.0.2"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "lxml" },+ { name = "pillow" },+ { name = "typing-extensions" },+ { name = "xlsxwriter" },+]+sdist = { url = "https://files.pythonhosted.org/packages/52/a9/0c0db8d37b2b8a645666f7fd8accea4c6224e013c42b1d5c17c93590cd06/python_pptx-1.0.2.tar.gz", hash = "sha256:479a8af0eaf0f0d76b6f00b0887732874ad2e3188230315290cd1f9dd9cc7095", size = 10109297, upload-time = "2024-08-07T17:33:37.772Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/d9/4f/00be2196329ebbff56ce564aa94efb0fbc828d00de250b1980de1a34ab49/python_pptx-1.0.2-py3-none-any.whl", hash = "sha256:160838e0b8565a8b1f67947675886e9fea18aa5e795db7ae531606d68e785cba", size = 472788, upload-time = "2024-08-07T17:33:28.192Z" },+]+[[package]]name = "pytz"version = "2025.2"@@ -2545,6 +2604,15 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/f4/24/2a3e3df732393fed8b3ebf2ec078f05546de641fe1b667ee316ec1dcf3b7/webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78", size = 11774, upload-time = "2017-04-05T20:21:32.581Z" },]+[[package]]+name = "xlsxwriter"+version = "3.2.9"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/46/2c/c06ef49dc36e7954e55b802a8b231770d286a9758b3d936bd1e04ce5ba88/xlsxwriter-3.2.9.tar.gz", hash = "sha256:254b1c37a368c444eac6e2f867405cc9e461b0ed97a3233b2ac1e574efb4140c", size = 215940, upload-time = "2025-09-16T00:16:21.63Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/3a/0c/3662f4a66880196a590b202f0db82d919dd2f89e99a27fadef91c4a33d41/xlsxwriter-3.2.9-py3-none-any.whl", hash = "sha256:9a5db42bc5dff014806c58a20b9eae7322a134abb6fce3c92c181bfb275ec5b3", size = 175315, upload-time = "2025-09-16T00:16:20.108Z" },+]+[[package]]name = "xxhash"version = "3.6.0"