Skip to content

Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.

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__.py
index 98e4ff942..75bf57e70 100644
--- a/openviking/parse/parsers/__init__.py
+++ b/openviking/parse/parsers/__init__.py
@@ -3,18 +3,28 @@
from .base_parser import BaseParser
from .code import CodeRepositoryParser
+from .epub import EPubParser
+from .excel import ExcelParser
from .html import HTMLParser, URLType, URLTypeDetector
from .markdown import MarkdownParser
from .pdf import PDFParser
+from .powerpoint import PowerPointParser
from .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.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
index 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 result
diff --git a/openviking/parse/parsers/word.py b/openviking/parse/parsers/word.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
index 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, Union
from openviking.parse.base import ParseResult
from 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 issues
from openviking.parse.parsers.html import HTMLParser
from openviking.parse.parsers.markdown import MarkdownParser
from openviking.parse.parsers.pdf import PDFParser
+from openviking.parse.parsers.powerpoint import PowerPointParser
from 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 dynamically
try:
from openviking.parse.parsers.code import CodeRepositoryParser
diff --git a/pyproject.toml b/pyproject.toml
index 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.lock
index 0633c6084..dc6aa6417 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1,5 +1,5 @@
version = 1
-revision = 3
+revision = 2
requires-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"