Asciidoctor Web PDF is a CLI tool that converts AsciiDoc documents to PDF using web technologies. It employs a multi-stage pipeline: Asciidoctor converts .adoc to HTML, Puppeteer renders the HTML via the Vivliostyle Viewer (CSS paged media), and pdf-lib adds PDF outline/bookmarks and metadata. The architecture features clean separation of concerns with dedicated modules for browser management, MathJax processing, syntax highlighting, outline generation, and metadata injection. Notable for its sophisticated handling of Node.js SEA binary execution paths and server-side MathJax rendering with proper async font loading.
OCRmyPDF is a mature, production-grade command-line tool and Python library that adds searchable OCR text layers to scanned PDFs, producing PDF/A-compliant output by default. The system ingests PDFs or images, optionally deskews/cleans pages via unpaper, rasterizes with Ghostscript or pypdfium2, runs Tesseract OCR, grafts the recognized text into the original PDF using a plugin-based pipeline, and performs image optimization with pngquant/jbig2enc. It supports multiple output formats (PDF/A-1b, PDF/A-2b, plain PDF), a plugin system for replacing OCR engines, rasterizers, and progress bars, and includes a directory watcher for batch processing. Architecture is a modular Python CLI/library with external subprocess orchestration; core abstractions include typed OcrOptions (pydantic), Executor concurrency, FontProvider chains, and the OcrElement data model. The codebase is exceptionally well-tested with a comprehensive suite of unit, integration, and plugin-level tests, and demonstrates advanced patterns for PDF repair, cross-platform tool discovery, and atomic file operations.
This repository provides safe, idiomatic Rust bindings to the MuPDF C library (Artifex Software), enabling programmatic reading, rendering, creation, and editing of PDF and other document formats. It is a library crate organized as a Cargo workspace with three sub-crates: `mupdf` (high-level API), `mupdf-sys` (FFI layer that compiles MuPDF from source), and optional font crates (`mupdf-fonts-droid`, `mupdf-fonts-noto`, `mupdf-fonts-sil`). The architecture is a classic FFI wrapper: `mupdf-sys` exposes raw C functions via `bindgen`, while `mupdf` provides safe Rust types (`Document`, `Page`, `Pixmap`, `PdfDocument`, `Shape`, etc.) with automatic resource management, error handling, and thread-safety checks. Key entry points include `Document::open()` for loading files, `Page::to_pixmap()` for rasterization, `Shape` for programmatic drawing, and `PdfDocument` for PDF-specific operations like annotation manipulation, form filling, and incremental saving. The library supports extensive feature flags (e.g., `js`, `xps`, `svg`, `tesseract`, `docx-output`) that control which MuPDF subsystems are compiled. The codebase demonstrates high craftsmanship through its safe wrapper patterns, builder-style APIs (e.g., `Shape`), extensible trait design (`FontLoader`, `NativeDevice`), and comprehensive test coverage including snapshot-based rendering tests and link extraction round-trip tests. It is not a data research project; it is a software library for document processing.
This is the Microsoft Open XML SDK, a production-grade .NET library for reading, writing, creating, and validating Office Open XML documents (Word, Excel, PowerPoint). It provides a strongly-typed DOM (OpenXmlElement hierarchy), LINQ-to-XML integration via generated XName constants, Flat OPC serialization, and a comprehensive validation framework based on the OOXML standard. The architecture combines hand-crafted foundations (OpenXmlElement, OpenXmlPart, OpenXmlPackage, FeatureCollection pattern) with schema-driven source generators that produce hundreds of typed classes, part definitions, and namespace constants from bundled JSON metadata. Key entry points are WordprocessingDocument, SpreadsheetDocument, and PresentationDocument, each with static factory methods (Open, Create, FromFlatOpc). The library is actively maintained by Microsoft, supports Office versions from 2007 through Microsoft365, and includes numerous samples, extensive xUnit tests, and performance benchmarks.
Presenton is an AI-powered presentation generation platform that allows users to create presentations from text prompts, document uploads, or template selections using multiple LLM and image providers. The application features a monorepo architecture with a FastAPI backend, Next.js frontend, and Electron desktop client. Key capabilities include AI-driven outline and slide generation, visual slide editing, document processing via LiteParse, export to PPTX/PDF formats, chat-based presentation refinement, and community template sharing. The system demonstrates strong engineering practices with modular service architecture, secure handling of sensitive data, and reusable components for configuration management, document conversion, and provider abstraction.
This repository is a mature Ruby gem (`pdf-reader`) that provides a comprehensive PDF parsing library. It implements a low-level PDF parser conforming to the PDF specification, enabling programmatic access to PDF content without rendering. The library supports text extraction (with UTF-8 conversion), metadata retrieval, page geometry, font handling (Type1, TrueType, Type3, CID), encryption (RC4, AES), and various PDF features like Form XObjects, inline images, and content stream processing. It is designed for document processing, text mining, and automated analysis of PDF files. The architecture follows a receiver/callback pattern for processing content streams, with `PDF::Reader` as the main entry point. Key modules include `PDF::Reader::Page` for high-level page access, `PDF::Reader::ObjectHash` for low-level object access, `PDF::Reader::Parser` for tokenization, and `PDF::Reader::Filter` for stream decompression. The library uses Sorbet for static type checking and includes a comprehensive test suite with over 120 spec files and numerous real-world PDF test fixtures. The codebase demonstrates solid engineering practices: clean abstractions (value objects like `Point`, `Rectangle`, `TextRun`), thread-safe caching (`SynchronizedCache`), optimized matrix operations (`TransformationMatrix`), and a pluggable width calculator system. It is actively maintained with support for multiple Ruby versions (2.1–4.0, JRuby, TruffleRuby) and has a well-documented changelog spanning over a decade of development.
The pywpsrpc repository provides Python bindings for the WPS Office RPC (Remote Procedure Call) interface, enabling automation of WPS Office applications (Writer, Presentation, Spreadsheets) on Linux. It allows Python scripts to create, edit, format, and convert documents, handle application events, and embed WPS Office windows in custom Qt/PySide2 applications. The library is structured into three main modules (rpcwpsapi, rpcwppapi, rpcetapi) corresponding to the three WPS Office applications, with shared utilities in the py/ directory. The bindings are generated using SIP from C++ interfaces, and the project includes a comprehensive test suite and example scripts demonstrating core functionality like document manipulation, formatting, and event handling.
NotebookLlaMa is a full-stack, open-source alternative to Google's NotebookLM, built on LlamaCloud and the LlamaIndex ecosystem. It provides a Streamlit-based web interface for uploading PDF documents, processing them through a multi-step workflow (parsing, extraction, summarization, Q&A generation, mind map creation), and optionally generating a podcast conversation using ElevenLabs TTS. The system uses an MCP server (FastMCP) to expose tools for document processing, mind map generation, and index querying, orchestrated by a LlamaIndex Workflow. Observability is handled via OpenTelemetry with traces exported to Jaeger and stored in PostgreSQL, with an export-to-Parquet capability. The codebase is well-structured, async-first, and includes comprehensive tests, a CLI setup wizard for embedding providers, and Docker Compose for infrastructure dependencies. It is actively maintained and demonstrates strong engineering practices.
This repository is a full-stack application for building knowledge graphs from unstructured data using Large Language Models (LLMs). The backend, built with FastAPI and LangChain, ingests documents from multiple sources (local files, web pages, YouTube, Wikipedia, S3, GCS), chunks them, and uses an LLM to extract entities and relationships, which are stored in a Neo4j graph database. The frontend, a React/TypeScript application, provides a user interface for uploading files, configuring extraction (schema, LLM model, chunking), visualizing the resulting graph, and interacting with the data through a retrieval-augmented generation (RAG) chatbot with multiple retrieval modes (vector, graph, fulltext, hybrid). The system includes post-processing features like community detection, deduplication, and orphan node cleanup, as well as token usage tracking and evaluation metrics (RAGAS). While primarily an application with a web UI, it also contains experimental notebooks (GraphRAG, chunk size evaluation) that serve a data research purpose, making it a hybrid codebase with a dominant application character.
The repository provides a specialized toolkit for creating and editing Microsoft Word documents (.docx) with a focus on Chinese academic formatting standards. It enables conversion of Markdown to formatted DOCX, including precise handling of three-line tables (三线表), mathematical formulas via LaTeX-to-OMML conversion, chapter-based heading numbering with Chinese numerals, and GB/T 7714-compliant citation formatting. Additionally, it offers utilities for manipulating existing DOCX files, such as accepting tracked changes using LibreOffice, adding comments via XML manipulation, and validating documents against included Office Open XML schemas. The architecture consists of independent Python and JavaScript scripts that function as command-line tools, with core functionality centered around the docx-js library for document generation and Python scripts for low-level XML operations.
AutoSkill is a comprehensive framework for extracting, managing, and evolving reusable 'skills' from conversational logs and documents. It operates as a modular application with multiple entry points: a web UI for interactive chat, a CLI for batch processing, and an OpenAI-compatible proxy server that injects relevant skills into LLM context. The system employs LLM-driven and heuristic pipelines to extract skill candidates, deduplicate and merge them, and persist them in a skill store with vector and BM25 retrieval. It also includes a self-evolution subsystem (SkillEvo) that replays experiences, evaluates performance, and mutates skills for improvement. The codebase is hybrid, containing both application components (web server, proxy, libraries) and data/research pipelines (document ingestion, trajectory extraction), but the dominant character is an application SDK designed for integration with agentic workflows. Notable craftsmanship is seen in standalone utilities like a CJK-aware text unit counter, an AST-based prompt patcher, a persistent BM25 index, and a LibreOffice socket shim, though the repo also suffers from significant code duplication (e.g., identical validators across docx/pptx/xlsx) and a large surface area of environment variables and external dependencies.
Eidolon is an open-source framework for building, deploying, and managing multi-agent AI applications. It provides a Python SDK with abstractions for LLM integration (OpenAI, Anthropic, Mistral, Ollama, Azure), retrieval-augmented generation (RAG) pipelines, memory systems (vector stores, symbolic memory, file storage), and document processing (loaders, parsers, splitters). Agents are configured declaratively via YAML and can communicate with each other, use tools, and stream responses. The framework includes a Kubernetes operator for production deployment, a web UI built with Next.js and React for chatbot interaction and developer tooling, and a TypeScript client library. It also features built-in agent types like SimpleAgent, RetrieverAgent, SQLAgent, and a Tree-of-Thought agent, along with logic units for web search, browser automation, and API integration.
This repository is a curated collection of Claude skills—markdown instructions and supporting scripts that enable Claude (or any MCP-compatible agent) to perform a wide range of tasks, from document manipulation (DOCX, PPTX, PDF, XLSX) and GIF animation to web testing, MCP server building, and automation of hundreds of third-party SaaS services via Composio's Rube MCP. The repo is primarily a skill library with a standardized template for each skill, but it also contains several well-crafted Python libraries (e.g., easing functions, particle systems, OOXML validation frameworks) that are genuinely reusable. The architecture is modular: each skill lives in its own directory with a SKILL.md and optional scripts. The heavy reliance on external services (Composio, Rube MCP) and the massive duplication of templated skill documentation introduce maintenance risks, but the core utility scripts demonstrate solid engineering craftsmanship.
SenseNova-Skills is a composable collection of AI agent skills for office automation, built around the SenseNova model family. It provides production-grade capabilities for image generation and recognition, presentation (PPT) creation, Excel data analysis, deep research with structured evidence, and multi-source search (academic, social, code, finance). The skills are designed to run in Agent Skills-compatible runtimes (OpenClaw, hermes-agent) and are bundled into the Raccoon product for enterprise use. The architecture is modular: each skill is a self-contained directory with a SKILL.md manifest, scripts, prompts, and schemas. The deep research skill implements a multi-agent pipeline with formal JSON schemas and validators. The PPT skill has a multi-stage pipeline from user input to HTML-to-PPTX conversion via Playwright. The codebase demonstrates solid engineering with reusable components like a shared LLM/VLM client, export pipeline libraries, and validation infrastructure. However, it suffers from duplicated utility code across skills, complex environment variable fallback chains, hardcoded paths, and dependency on external APIs and headless browsers. The repo is actively maintained with biweekly reports and frequent commits.