doc2md-lite 1.0.0__tar.gz

doc2md_lite-1.0.0/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+What changed in doc2md-lite, newest first.
+
+## 1.0.0 - 2026-11-04
+
+- First release.
+- Turns a text PDF or a saved HTML page into clean Markdown. Tables stay Markdown tables.
+- Free MCP server, `doc2md-lite-mcp`, with one tool, `convert_to_markdown`.
+- You can install it from PyPI with `pip install doc2md-lite`.

doc2md_lite-1.0.0/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 tidybyte
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

doc2md_lite-1.0.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include CHANGELOG.md
+include llms.txt
+include server.json
+recursive-include tests *.py *.pdf *.html

doc2md_lite-1.0.0/PKG-INFO

@@ -0,0 +1,170 @@
+Metadata-Version: 2.4
+Name: doc2md-lite
+Version: 1.0.0
+Summary: Turn a text PDF or HTML file into clean Markdown, with tables kept as Markdown tables. Runs locally. CLI and MCP server.
+Author: Tidy Byte Tools
+License-Expression: MIT
+Project-URL: Homepage, https://tidybyte.gumroad.com/l/frlkv
+Project-URL: Source, https://github.com/tidybytetools/doc2md-lite
+Project-URL: Issues, https://github.com/tidybytetools/doc2md-lite/issues
+Project-URL: Changelog, https://github.com/tidybytetools/doc2md-lite/blob/main/CHANGELOG.md
+Keywords: pdf,html,markdown,pdf-to-markdown,html-to-markdown,llm,rag,cli,mcp,mcp-server
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Text Processing :: Markup :: Markdown
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pdfplumber>=0.10
+Requires-Dist: beautifulsoup4>=4.12
+Requires-Dist: mcp<2,>=1.2
+Dynamic: license-file
+
+# doc2md-lite
+
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/tidybytetools/doc2md-lite/blob/main/LICENSE)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/)
+[![MCP server](https://img.shields.io/badge/MCP-stdio-purple.svg)](#use-it-from-claude-desktop-or-cursor-mcp)
+
+Free tool that turns a text PDF or a saved web page (.html) into clean Markdown. Tables stay real Markdown tables.
+Need Word files, chunks for AI search (RAG), whole folders or page ranges? The paid version does that: **[doc2md on Gumroad](https://tidybyte.gumroad.com/l/frlkv)**
+
+Runs on your own computer, so your files are never uploaded anywhere. MIT license. Python 3.10 or newer, on Windows, Mac and Linux.
+
+<!-- mcp-name: io.github.tidybytetools/doc2md-lite -->
+
+## Install
+
+```
+pip install doc2md-lite
+```
+
+Or use pipx, which keeps it in its own space:
+
+```
+pipx install doc2md-lite
+```
+
+Want the newest code from GitHub instead?
+
+```
+pip install git+https://github.com/tidybytetools/doc2md-lite
+```
+
+## Use it
+
+```
+doc2md-lite report.pdf                 # writes report.md
+doc2md-lite page.html -o page.md
+doc2md-lite report.pdf -o -            # print the Markdown on screen
+doc2md-lite report.pdf --tables text   # also find tables with no border lines
+```
+
+Example run:
+
+```
+Saved: report.md  (4 headings, 1 tables)
+```
+
+What you get from a PDF:
+
+```
+# Spring Store Report
+
+Our team checked every store in March. Most stores met the new goal...
+
+## Sales by region
+
+| Region | Stores | Sales |
+| --- | --- | --- |
+| North | 12 | $48,200 |
+| South | 9 | $39,950 |
+```
+
+What it keeps: headings (found by font size and bold in PDFs), paragraphs, bullet and numbered lists, tables, and in HTML also bold, italic, links and code blocks. From web pages it drops scripts, styles, menus and footers.
+
+When you run it in a terminal it ends with one short line about the paid version. `--quiet` turns it off, and it never shows when output is piped or redirected.
+
+## Known limits
+
+- **Scanned PDFs.** Pages that are just an image (no text layer) are skipped, and the tool tells you which ones.
+- **Headings in PDFs are a best guess** from font size and bold. Odd layouts may need a quick fix.
+- **Two-column PDFs** (like science papers) may mix the columns.
+- **One file at a time.** No folders, no page ranges, no Word files, no RAG chunks. The paid version has those.
+- **Files only.** It does not download web pages. Save the page first.
+
+## Lite vs paid
+
+| | lite (free) | [doc2md](https://tidybyte.gumroad.com/l/frlkv) |
+|---|---|---|
+| Text PDF and HTML to Markdown | yes | yes |
+| Tables kept as Markdown tables | yes | yes |
+| Word (.docx), with bold, italic, links and lists | no | yes |
+| RAG chunks (JSONL with page, heading path, size and overlap) | no | yes |
+| Whole folders, sub-folders too | no | yes |
+| Page ranges and password-protected PDFs | no | yes |
+
+## Other good free tools
+
+Pick what fits you. [MarkItDown](https://github.com/microsoft/markitdown) reads many more file types. [pandoc](https://pandoc.org/) is great for Word and HTML but does not read PDFs. [pymupdf4llm](https://github.com/pymupdf/RAG) is fast on PDFs but uses the AGPL license. doc2md-lite is small, MIT, keeps PDF tables as tables, and has an MCP server built in.
+
+## Use it from Claude Desktop or Cursor (MCP)
+
+There is a small free MCP server built in. It gives your AI app one tool, `convert_to_markdown`. It needs [uv](https://docs.astral.sh/uv/).
+
+Run it by hand to check it starts (it waits quietly for an app to talk to it):
+
+```
+uvx --from doc2md-lite doc2md-lite-mcp
+```
+
+Claude Desktop (`claude_desktop_config.json`) or Cursor (`~/.cursor/mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "doc2md-lite": {
+      "command": "uvx",
+      "args": ["--from", "doc2md-lite", "doc2md-lite-mcp"]
+    }
+  }
+}
+```
+
+Tool: `convert_to_markdown(path, tables="lines", output_path="")`. It returns the Markdown text. If you set `output_path`, it saves the file there and returns the path instead.
+
+## For AI agents
+
+- **Use when:** you have a local PDF with real text (you can select the words) or a saved HTML file, and you want Markdown to read or store.
+- **Don't use when:** the PDF is a scan, the file is .docx, or you need many files or chunks with page numbers. Use the paid version for those.
+- **Input:** a file path, plus optional `tables` (`lines`, `text`, `off`).
+- **Output:** Markdown text. Tables are Markdown tables with the first row as the header.
+- CLI exit code is 0 on success and 1 on error (message on stderr, or `{"ok": false, "error": ...}` with `--json`). See also [`llms.txt`](https://github.com/tidybytetools/doc2md-lite/blob/main/llms.txt).
+
+## Python
+
+```python
+from doc2md_lite import convert
+md, info = convert("report.pdf")   # info: type, tables, headings, scanned_pages
+```
+
+## Tests
+
+```
+pip install pdfplumber beautifulsoup4 reportlab "mcp<2"
+python3 -m unittest discover tests
+```
+
+## License
+
+MIT. See `LICENSE`.

doc2md_lite-1.0.0/README.md

@@ -0,0 +1,138 @@
+# doc2md-lite
+
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/tidybytetools/doc2md-lite/blob/main/LICENSE)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/)
+[![MCP server](https://img.shields.io/badge/MCP-stdio-purple.svg)](#use-it-from-claude-desktop-or-cursor-mcp)
+
+Free tool that turns a text PDF or a saved web page (.html) into clean Markdown. Tables stay real Markdown tables.
+Need Word files, chunks for AI search (RAG), whole folders or page ranges? The paid version does that: **[doc2md on Gumroad](https://tidybyte.gumroad.com/l/frlkv)**
+
+Runs on your own computer, so your files are never uploaded anywhere. MIT license. Python 3.10 or newer, on Windows, Mac and Linux.
+
+<!-- mcp-name: io.github.tidybytetools/doc2md-lite -->
+
+## Install
+
+```
+pip install doc2md-lite
+```
+
+Or use pipx, which keeps it in its own space:
+
+```
+pipx install doc2md-lite
+```
+
+Want the newest code from GitHub instead?
+
+```
+pip install git+https://github.com/tidybytetools/doc2md-lite
+```
+
+## Use it
+
+```
+doc2md-lite report.pdf                 # writes report.md
+doc2md-lite page.html -o page.md
+doc2md-lite report.pdf -o -            # print the Markdown on screen
+doc2md-lite report.pdf --tables text   # also find tables with no border lines
+```
+
+Example run:
+
+```
+Saved: report.md  (4 headings, 1 tables)
+```
+
+What you get from a PDF:
+
+```
+# Spring Store Report
+
+Our team checked every store in March. Most stores met the new goal...
+
+## Sales by region
+
+| Region | Stores | Sales |
+| --- | --- | --- |
+| North | 12 | $48,200 |
+| South | 9 | $39,950 |
+```
+
+What it keeps: headings (found by font size and bold in PDFs), paragraphs, bullet and numbered lists, tables, and in HTML also bold, italic, links and code blocks. From web pages it drops scripts, styles, menus and footers.
+
+When you run it in a terminal it ends with one short line about the paid version. `--quiet` turns it off, and it never shows when output is piped or redirected.
+
+## Known limits
+
+- **Scanned PDFs.** Pages that are just an image (no text layer) are skipped, and the tool tells you which ones.
+- **Headings in PDFs are a best guess** from font size and bold. Odd layouts may need a quick fix.
+- **Two-column PDFs** (like science papers) may mix the columns.
+- **One file at a time.** No folders, no page ranges, no Word files, no RAG chunks. The paid version has those.
+- **Files only.** It does not download web pages. Save the page first.
+
+## Lite vs paid
+
+| | lite (free) | [doc2md](https://tidybyte.gumroad.com/l/frlkv) |
+|---|---|---|
+| Text PDF and HTML to Markdown | yes | yes |
+| Tables kept as Markdown tables | yes | yes |
+| Word (.docx), with bold, italic, links and lists | no | yes |
+| RAG chunks (JSONL with page, heading path, size and overlap) | no | yes |
+| Whole folders, sub-folders too | no | yes |
+| Page ranges and password-protected PDFs | no | yes |
+
+## Other good free tools
+
+Pick what fits you. [MarkItDown](https://github.com/microsoft/markitdown) reads many more file types. [pandoc](https://pandoc.org/) is great for Word and HTML but does not read PDFs. [pymupdf4llm](https://github.com/pymupdf/RAG) is fast on PDFs but uses the AGPL license. doc2md-lite is small, MIT, keeps PDF tables as tables, and has an MCP server built in.
+
+## Use it from Claude Desktop or Cursor (MCP)
+
+There is a small free MCP server built in. It gives your AI app one tool, `convert_to_markdown`. It needs [uv](https://docs.astral.sh/uv/).
+
+Run it by hand to check it starts (it waits quietly for an app to talk to it):
+
+```
+uvx --from doc2md-lite doc2md-lite-mcp
+```
+
+Claude Desktop (`claude_desktop_config.json`) or Cursor (`~/.cursor/mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "doc2md-lite": {
+      "command": "uvx",
+      "args": ["--from", "doc2md-lite", "doc2md-lite-mcp"]
+    }
+  }
+}
+```
+
+Tool: `convert_to_markdown(path, tables="lines", output_path="")`. It returns the Markdown text. If you set `output_path`, it saves the file there and returns the path instead.
+
+## For AI agents
+
+- **Use when:** you have a local PDF with real text (you can select the words) or a saved HTML file, and you want Markdown to read or store.
+- **Don't use when:** the PDF is a scan, the file is .docx, or you need many files or chunks with page numbers. Use the paid version for those.
+- **Input:** a file path, plus optional `tables` (`lines`, `text`, `off`).
+- **Output:** Markdown text. Tables are Markdown tables with the first row as the header.
+- CLI exit code is 0 on success and 1 on error (message on stderr, or `{"ok": false, "error": ...}` with `--json`). See also [`llms.txt`](https://github.com/tidybytetools/doc2md-lite/blob/main/llms.txt).
+
+## Python
+
+```python
+from doc2md_lite import convert
+md, info = convert("report.pdf")   # info: type, tables, headings, scanned_pages
+```
+
+## Tests
+
+```
+pip install pdfplumber beautifulsoup4 reportlab "mcp<2"
+python3 -m unittest discover tests
+```
+
+## License
+
+MIT. See `LICENSE`.

doc2md_lite-1.0.0/doc2md_lite.egg-info/PKG-INFO

@@ -0,0 +1,170 @@
+Metadata-Version: 2.4
+Name: doc2md-lite
+Version: 1.0.0
+Summary: Turn a text PDF or HTML file into clean Markdown, with tables kept as Markdown tables. Runs locally. CLI and MCP server.
+Author: Tidy Byte Tools
+License-Expression: MIT
+Project-URL: Homepage, https://tidybyte.gumroad.com/l/frlkv
+Project-URL: Source, https://github.com/tidybytetools/doc2md-lite
+Project-URL: Issues, https://github.com/tidybytetools/doc2md-lite/issues
+Project-URL: Changelog, https://github.com/tidybytetools/doc2md-lite/blob/main/CHANGELOG.md
+Keywords: pdf,html,markdown,pdf-to-markdown,html-to-markdown,llm,rag,cli,mcp,mcp-server
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Text Processing :: Markup :: Markdown
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pdfplumber>=0.10
+Requires-Dist: beautifulsoup4>=4.12
+Requires-Dist: mcp<2,>=1.2
+Dynamic: license-file
+
+# doc2md-lite
+
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/tidybytetools/doc2md-lite/blob/main/LICENSE)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/)
+[![MCP server](https://img.shields.io/badge/MCP-stdio-purple.svg)](#use-it-from-claude-desktop-or-cursor-mcp)
+
+Free tool that turns a text PDF or a saved web page (.html) into clean Markdown. Tables stay real Markdown tables.
+Need Word files, chunks for AI search (RAG), whole folders or page ranges? The paid version does that: **[doc2md on Gumroad](https://tidybyte.gumroad.com/l/frlkv)**
+
+Runs on your own computer, so your files are never uploaded anywhere. MIT license. Python 3.10 or newer, on Windows, Mac and Linux.
+
+<!-- mcp-name: io.github.tidybytetools/doc2md-lite -->
+
+## Install
+
+```
+pip install doc2md-lite
+```
+
+Or use pipx, which keeps it in its own space:
+
+```
+pipx install doc2md-lite
+```
+
+Want the newest code from GitHub instead?
+
+```
+pip install git+https://github.com/tidybytetools/doc2md-lite
+```
+
+## Use it
+
+```
+doc2md-lite report.pdf                 # writes report.md
+doc2md-lite page.html -o page.md
+doc2md-lite report.pdf -o -            # print the Markdown on screen
+doc2md-lite report.pdf --tables text   # also find tables with no border lines
+```
+
+Example run:
+
+```
+Saved: report.md  (4 headings, 1 tables)
+```
+
+What you get from a PDF:
+
+```
+# Spring Store Report
+
+Our team checked every store in March. Most stores met the new goal...
+
+## Sales by region
+
+| Region | Stores | Sales |
+| --- | --- | --- |
+| North | 12 | $48,200 |
+| South | 9 | $39,950 |
+```
+
+What it keeps: headings (found by font size and bold in PDFs), paragraphs, bullet and numbered lists, tables, and in HTML also bold, italic, links and code blocks. From web pages it drops scripts, styles, menus and footers.
+
+When you run it in a terminal it ends with one short line about the paid version. `--quiet` turns it off, and it never shows when output is piped or redirected.
+
+## Known limits
+
+- **Scanned PDFs.** Pages that are just an image (no text layer) are skipped, and the tool tells you which ones.
+- **Headings in PDFs are a best guess** from font size and bold. Odd layouts may need a quick fix.
+- **Two-column PDFs** (like science papers) may mix the columns.
+- **One file at a time.** No folders, no page ranges, no Word files, no RAG chunks. The paid version has those.
+- **Files only.** It does not download web pages. Save the page first.
+
+## Lite vs paid
+
+| | lite (free) | [doc2md](https://tidybyte.gumroad.com/l/frlkv) |
+|---|---|---|
+| Text PDF and HTML to Markdown | yes | yes |
+| Tables kept as Markdown tables | yes | yes |
+| Word (.docx), with bold, italic, links and lists | no | yes |
+| RAG chunks (JSONL with page, heading path, size and overlap) | no | yes |
+| Whole folders, sub-folders too | no | yes |
+| Page ranges and password-protected PDFs | no | yes |
+
+## Other good free tools
+
+Pick what fits you. [MarkItDown](https://github.com/microsoft/markitdown) reads many more file types. [pandoc](https://pandoc.org/) is great for Word and HTML but does not read PDFs. [pymupdf4llm](https://github.com/pymupdf/RAG) is fast on PDFs but uses the AGPL license. doc2md-lite is small, MIT, keeps PDF tables as tables, and has an MCP server built in.
+
+## Use it from Claude Desktop or Cursor (MCP)
+
+There is a small free MCP server built in. It gives your AI app one tool, `convert_to_markdown`. It needs [uv](https://docs.astral.sh/uv/).
+
+Run it by hand to check it starts (it waits quietly for an app to talk to it):
+
+```
+uvx --from doc2md-lite doc2md-lite-mcp
+```
+
+Claude Desktop (`claude_desktop_config.json`) or Cursor (`~/.cursor/mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "doc2md-lite": {
+      "command": "uvx",
+      "args": ["--from", "doc2md-lite", "doc2md-lite-mcp"]
+    }
+  }
+}
+```
+
+Tool: `convert_to_markdown(path, tables="lines", output_path="")`. It returns the Markdown text. If you set `output_path`, it saves the file there and returns the path instead.
+
+## For AI agents
+
+- **Use when:** you have a local PDF with real text (you can select the words) or a saved HTML file, and you want Markdown to read or store.
+- **Don't use when:** the PDF is a scan, the file is .docx, or you need many files or chunks with page numbers. Use the paid version for those.
+- **Input:** a file path, plus optional `tables` (`lines`, `text`, `off`).
+- **Output:** Markdown text. Tables are Markdown tables with the first row as the header.
+- CLI exit code is 0 on success and 1 on error (message on stderr, or `{"ok": false, "error": ...}` with `--json`). See also [`llms.txt`](https://github.com/tidybytetools/doc2md-lite/blob/main/llms.txt).
+
+## Python
+
+```python
+from doc2md_lite import convert
+md, info = convert("report.pdf")   # info: type, tables, headings, scanned_pages
+```
+
+## Tests
+
+```
+pip install pdfplumber beautifulsoup4 reportlab "mcp<2"
+python3 -m unittest discover tests
+```
+
+## License
+
+MIT. See `LICENSE`.

doc2md_lite-1.0.0/doc2md_lite.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+CHANGELOG.md
+LICENSE
+MANIFEST.in
+README.md
+doc2md_lite.py
+doc2md_lite_mcp.py
+llms.txt
+pyproject.toml
+server.json
+doc2md_lite.egg-info/PKG-INFO
+doc2md_lite.egg-info/SOURCES.txt
+doc2md_lite.egg-info/dependency_links.txt
+doc2md_lite.egg-info/entry_points.txt
+doc2md_lite.egg-info/requires.txt
+doc2md_lite.egg-info/top_level.txt
+tests/test_lite.py
+tests/test_mcp.py
+tests/fixtures/returns-help.html
+tests/fixtures/store-report.pdf

doc2md_lite-1.0.0/doc2md_lite.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

doc2md_lite-1.0.0/doc2md_lite.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+doc2md-lite = doc2md_lite:main
+doc2md-lite-mcp = doc2md_lite_mcp:main

doc2md_lite-1.0.0/doc2md_lite.egg-info/requires.txt

@@ -0,0 +1,3 @@
+pdfplumber>=0.10
+beautifulsoup4>=4.12
+mcp<2,>=1.2

doc2md_lite-1.0.0/doc2md_lite.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+doc2md_lite
+doc2md_lite_mcp

doc2md_lite-1.0.0/doc2md_lite.py

@@ -0,0 +1,379 @@
+#!/usr/bin/env python3
+"""doc2md-lite: turn a text PDF or a saved HTML page into clean Markdown. Tables stay Markdown tables.
+Free, MIT license. Runs offline.
+
+Usage:
+  doc2md-lite report.pdf             # writes report.md
+  doc2md-lite page.html -o page.md
+  doc2md-lite page.html -o -         # print to screen
+
+Paid version (Word files, RAG chunks, whole folders, page picking): https://tidybyte.gumroad.com/l/frlkv
+"""
+import argparse, json, os, re, sys
+from collections import Counter
+
+__version__ = "1.0.0"
+PAID_URL = "https://tidybyte.gumroad.com/l/frlkv"
+
+
+# ---------- shared helpers ----------
+
+def parse_pages(spec, total):
+    """'1,3-5' -> [1,3,4,5] (1-based). None means every page."""
+    if not spec:
+        return list(range(1, total + 1))
+    pages = []
+    for part in spec.split(","):
+        part = part.strip()
+        if not part:
+            continue
+        if "-" in part:
+            a, b = part.split("-", 1)
+            pages.extend(range(int(a) if a else 1, (int(b) if b else total) + 1))
+        else:
+            pages.append(int(part))
+    bad = [p for p in pages if p < 1 or p > total]
+    if bad:
+        raise ValueError(f"page {bad[0]} is out of range (file has {total} pages)")
+    return sorted(set(pages))
+
+
+def _clean_cell(c):
+    if c is None:
+        return ""
+    return re.sub(r"\s+", " ", str(c)).strip()
+
+
+def clean_table(rows):
+    rows = [[_clean_cell(c) for c in r] for r in rows]
+    rows = [r for r in rows if any(r)]
+    if not rows:
+        return []
+    width = max(len(r) for r in rows)
+    rows = [r + [""] * (width - len(r)) for r in rows]
+    keep = [i for i in range(width) if any(r[i] for r in rows)]
+    return [[r[i] for i in keep] for r in rows]
+
+
+def md_table(rows):
+    """Rows (first row = header) -> Markdown table text."""
+    rows = clean_table(rows)
+    if not rows:
+        return ""
+    esc = lambda c: c.replace("\\", "\\\\").replace("|", "\\|")
+    head = rows[0]
+    out = ["| " + " | ".join(esc(c) for c in head) + " |",
+           "|" + "|".join(" --- " for _ in head) + "|"]
+    out += ["| " + " | ".join(esc(c) for c in r) + " |" for r in rows[1:]]
+    return "\n".join(out)
+
+
+def block(kind, text, page=None, level=0):
+    return {"kind": kind, "text": text, "page": page, "level": level}
+
+
+def blocks_to_md(blocks):
+    out = []
+    for b in blocks:
+        if b["kind"] == "heading":
+            out.append("#" * b["level"] + " " + b["text"])
+        else:
+            out.append(b["text"])
+    md = "\n\n".join(x.strip("\n") for x in out if x.strip())
+    md = re.sub(r"\n{3,}", "\n\n", md)
+    return md.strip() + "\n"
+
+
+# ---------- PDF ----------
+
+BULLET_RE = re.compile(r"^\s*[\u2022\u25cf\u25aa\u2013\u00b7*\-]\s+")
+NUM_RE = re.compile(r"^\s*(\d{1,3})[.)]\s+")
+
+
+def _inside(obj, boxes):
+    x = (obj["x0"] + obj["x1"]) / 2
+    y = (obj["top"] + obj["bottom"]) / 2
+    return any(b[0] <= x <= b[2] and b[1] <= y <= b[3] for b in boxes)
+
+
+def pdf_blocks(path, pages=None, tables="lines", password=None):
+    """Read a text PDF into blocks. tables: 'lines' (ruled tables), 'text' (also space-aligned), 'off'."""
+    import pdfplumber
+    out = []
+    with pdfplumber.open(path, password=password) as pdf:
+        nums = parse_pages(pages, len(pdf.pages))
+        sizes = Counter()
+        for pno in nums:  # body size = the most common font size
+            for ch in pdf.pages[pno - 1].chars:
+                sizes[round(ch["size"], 1)] += 1
+        body = sizes.most_common(1)[0][0] if sizes else 10
+        bigger = sorted({s for s in sizes if s >= body * 1.15}, reverse=True)[:3]
+        level_of = {s: i + 1 for i, s in enumerate(bigger)}
+        scanned = []
+        for pno in nums:
+            page = pdf.pages[pno - 1]
+            if not page.chars:
+                scanned.append(pno)
+                continue
+            items = []
+            boxes = []
+            if tables != "off":
+                st = {"vertical_strategy": "lines", "horizontal_strategy": "lines"}
+                found = page.find_tables(st)
+                if not found and tables == "text":
+                    found = page.find_tables({"vertical_strategy": "text", "horizontal_strategy": "text"})
+                for t in found:
+                    rows = clean_table(t.extract())
+                    if len(rows) >= 2 or (rows and tables == "lines" and len(rows[0]) > 1):
+                        boxes.append(t.bbox)
+                        items.append((t.bbox[1], block("table", md_table(rows), pno)))
+            text_page = page.filter(lambda o: o.get("object_type") != "char" or not _inside(o, boxes)) if boxes else page
+            lines = text_page.extract_text_lines(return_chars=True)
+            para, last = [], None
+            def flush():
+                if para:
+                    items.append((para[0][0], block("para", " ".join(t for _, t in para), pno)))
+                    para.clear()
+            for ln in lines:
+                txt = re.sub(r"\(cid:\d+\)", "", ln["text"].replace("(cid:127)", "\u2022")).strip()
+                if not txt:
+                    continue
+                size = round(Counter(round(c["size"], 1) for c in ln["chars"]).most_common(1)[0][0], 1)
+                bold = sum("Bold" in c.get("fontname", "") for c in ln["chars"]) > len(ln["chars"]) * 0.8
+                lvl = level_of.get(size)
+                if lvl is None and bold and len(txt) < 80 and not txt.endswith((".", ",", ":")):
+                    lvl = min(len(bigger) + 1, 6)
+                if lvl:
+                    flush()
+                    items.append((ln["top"], block("heading", txt, pno, lvl)))
+                    last = None
+                    continue
+                m = BULLET_RE.match(txt) or NUM_RE.match(txt)
+                if m:
+                    flush()
+                    mark = (m.group(1) + ".") if m.re is NUM_RE else "-"
+                    items.append((ln["top"], block("list", f"{mark} {txt[m.end():].strip()}", pno)))
+                    last = ln
+                    continue
+                gap = (ln["top"] - last["bottom"]) if last else 0
+                if last and gap > size * 0.9:
+                    flush()
+                if para and para[-1][1].endswith("-") and not para[-1][1].endswith(" -"):
+                    para[-1] = (para[-1][0], para[-1][1][:-1] + txt)  # re-join a split word
+                else:
+                    para.append((ln["top"], txt))
+                last = ln
+            flush()
+            items.sort(key=lambda x: x[0])
+            merged = []
+            for _, b in items:  # glue list items into one list block
+                if merged and b["kind"] == "list" and merged[-1]["kind"] == "list" and merged[-1]["page"] == b["page"]:
+                    merged[-1]["text"] += "\n" + b["text"]
+                else:
+                    merged.append(b)
+            out.extend(merged)
+    return out, scanned
+
+
+# ---------- HTML ----------
+
+SKIP_TAGS = {"script", "style", "noscript", "head", "template", "svg", "iframe", "form", "button"}
+CHROME_TAGS = {"nav", "footer", "aside"}
+
+
+def _inline(node):
+    return _inline_nodes(node.children)
+
+
+def _inline_nodes(children):
+    from bs4 import NavigableString, Comment
+    out = []
+    for c in children:
+        if isinstance(c, Comment):
+            continue
+        if isinstance(c, NavigableString):
+            out.append(re.sub(r"\s+", " ", str(c)))
+            continue
+        n = c.name
+        if n in SKIP_TAGS:
+            continue
+        inner = _inline(c)
+        core = inner.strip()
+        if n == "br":
+            out.append("  \n")
+        elif n in ("strong", "b") and core:
+            out.append(inner.replace(core, f"**{core}**", 1))
+        elif n in ("em", "i") and core:
+            out.append(inner.replace(core, f"*{core}*", 1))
+        elif n == "code" and core:
+            out.append(f"`{core}`")
+        elif n == "a" and core and c.get("href") and not c["href"].startswith(("javascript:", "#")):
+            out.append(f"[{core}]({c['href']})")
+        elif n == "img":
+            alt = c.get("alt", "").strip()
+            if alt:
+                out.append(f"![{alt}]({c.get('src', '')})")
+        else:
+            out.append(inner)
+    return "".join(out)
+
+
+def _html_list(node, depth=0):
+    lines, i = [], 1
+    for li in node.find_all("li", recursive=False):
+        subs = [s.extract() for s in li.find_all(["ul", "ol"], recursive=False)]
+        mark = f"{i}." if node.name == "ol" else "-"
+        lines.append("    " * depth + f"{mark} " + re.sub(r"\s+", " ", _inline(li)).strip())
+        for s in subs:
+            lines.extend(_html_list(s, depth + 1))
+        i += 1
+    return lines
+
+
+def _html_walk(node, out):
+    from bs4 import NavigableString, Tag
+    buf = []
+    def flush():
+        t = re.sub(r"[ \t]+", " ", "".join(buf)).strip()
+        if t:
+            out.append(block("para", t))
+        buf.clear()
+    for c in node.children:
+        if not isinstance(c, Tag):
+            if isinstance(c, NavigableString) and type(c).__name__ == "NavigableString":
+                buf.append(str(c))
+            continue
+        n = c.name
+        if n in SKIP_TAGS:
+            continue
+        if re.fullmatch(r"h[1-6]", n):
+            flush()
+            t = re.sub(r"\s+", " ", c.get_text(" ")).strip()
+            if t:
+                out.append(block("heading", t, level=int(n[1])))
+        elif n == "p":
+            flush()
+            t = re.sub(r"[ \t]+", " ", _inline(c)).strip()
+            if t:
+                out.append(block("para", t))
+        elif n in ("ul", "ol"):
+            flush()
+            lines = _html_list(c)
+            if lines:
+                out.append(block("list", "\n".join(lines)))
+        elif n == "table":
+            flush()
+            rows = []
+            for tr in c.find_all("tr"):
+                if tr.find_parent("table") is not c:
+                    continue
+                rows.append([re.sub(r"\s+", " ", _inline(td)).strip() for td in tr.find_all(["th", "td"], recursive=False)])
+            t = md_table(rows)
+            if t:
+                out.append(block("table", t))
+        elif n == "pre":
+            flush()
+            code = c.get_text()
+            lang = ""
+            cd = c.find("code")
+            if cd:
+                for cls in cd.get("class", []):
+                    if cls.startswith("language-"):
+                        lang = cls[9:]
+            out.append(block("code", f"```{lang}\n{code.strip(chr(10))}\n```"))
+        elif n == "blockquote":
+            flush()
+            sub = []
+            _html_walk(c, sub)
+            txt = blocks_to_md(sub).strip()
+            if txt:
+                out.append(block("para", "\n".join("> " + l if l else ">" for l in txt.split("\n"))))
+        elif n == "hr":
+            flush()
+            out.append(block("para", "---"))
+        elif n in ("div", "section", "article", "main", "body", "html", "header", "figure", "nav", "footer", "aside", "dl", "details"):
+            flush()
+            _html_walk(c, out)
+        else:
+            buf.append(_inline_nodes([c]))
+    flush()
+
+
+def html_blocks(path_or_text, keep_chrome=False, is_text=False):
+    from bs4 import BeautifulSoup
+    if is_text:
+        raw = path_or_text
+    else:
+        with open(path_or_text, "rb") as f:
+            raw = f.read()
+    soup = BeautifulSoup(raw, "html.parser")
+    title = soup.title.get_text(" ", strip=True) if soup.title else ""
+    for t in soup.find_all(list(SKIP_TAGS)):
+        t.decompose()
+    if not keep_chrome:
+        for t in soup.find_all(list(CHROME_TAGS)):
+            t.decompose()
+    root = soup.find("main") or soup.find("article") or soup.body or soup
+    out = []
+    _html_walk(root, out)
+    if not any(b["kind"] == "heading" and b["level"] == 1 for b in out) and title:
+        out.insert(0, block("heading", title, level=1))
+    return out
+
+
+# ---------- top level ----------
+
+def convert(path, tables="lines"):
+    """Return (markdown, info) for one .pdf or .html file."""
+    ext = os.path.splitext(path)[1].lower()
+    info = {"type": ext[1:], "scanned_pages": []}
+    if ext == ".pdf":
+        blocks, info["scanned_pages"] = pdf_blocks(path, None, tables)
+    elif ext in (".html", ".htm"):
+        blocks = html_blocks(path)
+    else:
+        raise ValueError(f"lite reads .pdf and .html only (got '{ext}'). Word files need the paid version: {PAID_URL}")
+    info["tables"] = sum(1 for b in blocks if b["kind"] == "table")
+    info["headings"] = sum(1 for b in blocks if b["kind"] == "heading")
+    return blocks_to_md(blocks), info
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(description="Turn a text PDF or HTML file into clean Markdown.")
+    ap.add_argument("file", help="a .pdf or .html file")
+    ap.add_argument("-o", "--output", help="output .md file, or - for the screen. Default: next to the input")
+    ap.add_argument("--tables", choices=["lines", "text", "off"], default="lines",
+                    help="PDF tables: lines (with borders, default), text (also lined up by spaces), off")
+    ap.add_argument("--json", action="store_true", help="print a JSON summary (for scripts and agents)")
+    ap.add_argument("-q", "--quiet", action="store_true", help="no tip about the paid version")
+    ap.add_argument("--version", action="version", version=__version__)
+    a = ap.parse_args(argv)
+    try:
+        if not os.path.isfile(a.file):
+            raise FileNotFoundError(f"file not found: {a.file}")
+        md, info = convert(a.file, a.tables)
+        out = a.output or os.path.splitext(a.file)[0] + ".md"
+        if out == "-":
+            sys.stdout.write(md)
+            return 0
+        with open(out, "w", encoding="utf-8") as f:
+            f.write(md)
+        if a.json:
+            print(json.dumps({"ok": True, "input": a.file, "output": out, "chars": len(md), **info}))
+        else:
+            print(f"Saved: {out}  ({info['headings']} headings, {info['tables']} tables)")
+            if info["scanned_pages"]:
+                print(f"Note: pages {info['scanned_pages']} have no text (scanned) and were skipped.")
+            if not a.quiet and sys.stdout.isatty():
+                print(f"Need Word files, RAG chunks or whole folders? {PAID_URL}")
+        return 0
+    except Exception as e:
+        if a.json:
+            print(json.dumps({"ok": False, "error": str(e)}))
+        else:
+            print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

doc2md_lite-1.0.0/doc2md_lite_mcp.py

@@ -0,0 +1,43 @@
+"""Free MCP server for doc2md-lite (stdio).
+
+Run:  uvx --from git+https://github.com/tidybytetools/doc2md-lite doc2md-lite-mcp
+"""
+import os
+from mcp.server.fastmcp import FastMCP
+import doc2md_lite as lite
+
+mcp = FastMCP("doc2md-lite")
+
+
+@mcp.tool()
+def convert_to_markdown(path: str, tables: str = "lines", output_path: str = "") -> str:
+    """Turn a local text PDF or saved HTML file into clean Markdown.
+
+    path: full path to a .pdf or .html file on this computer.
+    tables: PDF tables. "lines" (default) finds tables with border lines, "text" also tries
+    tables lined up by spaces, "off" gives plain text.
+    output_path: optional. If set, the Markdown is saved there and that path is returned.
+    If empty, the Markdown text is returned.
+
+    Tables come back as Markdown tables. Scanned (image-only) PDF pages have no text and are skipped.
+    """
+    path = os.path.expanduser(path)
+    if not os.path.isfile(path):
+        raise FileNotFoundError(f"file not found: {path}")
+    if tables not in ("lines", "text", "off"):
+        raise ValueError("tables must be lines, text or off")
+    md, _info = lite.convert(path, tables)
+    if output_path:
+        output_path = os.path.expanduser(output_path)
+        with open(output_path, "w", encoding="utf-8") as f:
+            f.write(md)
+        return output_path
+    return md
+
+
+def main():
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

doc2md_lite-1.0.0/llms.txt

@@ -0,0 +1,19 @@
+# doc2md-lite
+
+> Free, MIT-licensed tool that turns a local text PDF or saved HTML file into clean Markdown. Tables become Markdown tables. Runs offline. Has a CLI, a Python API and a stdio MCP server.
+
+- Install: `pip install doc2md-lite` (or from GitHub: `pip install git+https://github.com/tidybytetools/doc2md-lite`)
+- CLI: `doc2md-lite file.pdf -o out.md [--tables lines|text|off] [--json]`. `-o -` prints the Markdown. Exit 0 ok, 1 error.
+- Python: `from doc2md_lite import convert; md, info = convert("file.pdf")` where info is {"type", "tables", "headings", "scanned_pages"}.
+- MCP: `uvx --from doc2md-lite doc2md-lite-mcp` exposes `convert_to_markdown(path, tables="lines", output_path="") -> str` (Markdown text, or the saved path if output_path is set).
+
+## Use when
+- You need a PDF with a text layer, or an HTML file, as Markdown for an LLM, a wiki or notes.
+
+## Don't use when
+- The PDF is scanned (pages are skipped), the file is Word (.docx), or you need RAG chunks with page and heading info, whole folders, or page ranges. The paid version does those: https://tidybyte.gumroad.com/l/frlkv
+- You need to download web pages. This only reads files already on disk.
+
+## Links
+- [README](https://github.com/tidybytetools/doc2md-lite/blob/main/README.md)
+- [Paid version](https://tidybyte.gumroad.com/l/frlkv)

doc2md_lite-1.0.0/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "doc2md-lite"
+version = "1.0.0"
+description = "Turn a text PDF or HTML file into clean Markdown, with tables kept as Markdown tables. Runs locally. CLI and MCP server."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{name = "Tidy Byte Tools"}]
+requires-python = ">=3.10"
+dependencies = [
+  "pdfplumber>=0.10",
+  "beautifulsoup4>=4.12",
+  "mcp>=1.2,<2",
+]
+keywords = ["pdf", "html", "markdown", "pdf-to-markdown", "html-to-markdown", "llm", "rag", "cli", "mcp", "mcp-server"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "Intended Audience :: End Users/Desktop",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Text Processing :: Markup :: Markdown",
+  "Topic :: Utilities",
+]
+
+[project.urls]
+Homepage = "https://tidybyte.gumroad.com/l/frlkv"
+Source = "https://github.com/tidybytetools/doc2md-lite"
+Issues = "https://github.com/tidybytetools/doc2md-lite/issues"
+Changelog = "https://github.com/tidybytetools/doc2md-lite/blob/main/CHANGELOG.md"
+
+[project.scripts]
+doc2md-lite = "doc2md_lite:main"
+doc2md-lite-mcp = "doc2md_lite_mcp:main"
+
+[tool.setuptools]
+py-modules = ["doc2md_lite", "doc2md_lite_mcp"]

doc2md_lite-1.0.0/server.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.tidybytetools/doc2md-lite",
+  "title": "doc2md-lite",
+  "description": "Turn local text PDFs and HTML files into clean Markdown, tables kept. Runs on your computer.",
+  "repository": {
+    "url": "https://github.com/tidybytetools/doc2md-lite",
+    "source": "github"
+  },
+  "websiteUrl": "https://github.com/tidybytetools/doc2md-lite",
+  "version": "1.0.0",
+  "packages": [
+    {
+      "registryType": "pypi",
+      "registryBaseUrl": "https://pypi.org",
+      "identifier": "doc2md-lite",
+      "version": "1.0.0",
+      "runtimeHint": "uvx",
+      "transport": {
+        "type": "stdio"
+      }
+    }
+  ]
+}

doc2md_lite-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

doc2md_lite-1.0.0/tests/fixtures/returns-help.html

@@ -0,0 +1,10 @@
+<!doctype html><html><head><title>Help Center: Returns</title><style>body{color:red}</style>
+<script>console.log('x')</script></head><body>
+<nav><a href="/">Home</a> | <a href="/shop">Shop</a></nav>
+<main><h1>How returns work</h1>
+<p>You can send back most items within <strong>30 days</strong>. See the <a href="https://example.com/policy">full policy</a>.</p>
+<h2>Steps</h2><ol><li>Open your order.</li><li>Pick <em>Return item</em>.<ul><li>Print the label.</li></ul></li><li>Drop it off.</li></ol>
+<h2>Refund times</h2>
+<table><tr><th>Paid with</th><th>Refund time</th></tr><tr><td>Card</td><td>3-5 days</td></tr><tr><td>Gift card</td><td>1 day</td></tr></table>
+<h3>Code for developers</h3><pre><code class="language-bash">curl https://example.com/api/returns</code></pre>
+</main><footer>Copyright Example Shop</footer></body></html>

doc2md_lite-1.0.0/tests/fixtures/store-report.pdf

@@ -0,0 +1,93 @@
+%PDF-1.3
+%���� ReportLab Generated PDF document (opensource)
+1 0 obj
+<<
+/F1 2 0 R /F2 3 0 R
+>>
+endobj
+2 0 obj
+<<
+/BaseFont /Helvetica /Encoding /WinAnsiEncoding /Name /F1 /Subtype /Type1 /Type /Font
+>>
+endobj
+3 0 obj
+<<
+/BaseFont /Helvetica-Bold /Encoding /WinAnsiEncoding /Name /F2 /Subtype /Type1 /Type /Font
+>>
+endobj
+4 0 obj
+<<
+/Contents 9 0 R /MediaBox [ 0 0 612 792 ] /Parent 8 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+5 0 obj
+<<
+/Contents 10 0 R /MediaBox [ 0 0 612 792 ] /Parent 8 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+6 0 obj
+<<
+/PageMode /UseNone /Pages 8 0 R /Type /Catalog
+>>
+endobj
+7 0 obj
+<<
+/Author (anonymous) /CreationDate (D:20261104020609-06'00') /Creator (anonymous) /Keywords () /ModDate (D:20261104020609-06'00') /Producer (ReportLab PDF Library - \(opensource\)) 
+  /Subject (unspecified) /Title (untitled) /Trapped /False
+>>
+endobj
+8 0 obj
+<<
+/Count 2 /Kids [ 4 0 R 5 0 R ] /Type /Pages
+>>
+endobj
+9 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 624
+>>
+stream
+Gat=i9lJK7!/Bt>(%7h$5ZNW2mjj2#+Z?,R&f30<l6_'/Y%!a!ruTp3Z?.OS=cIa3m,tdK=DnImr?M$NBRgURhVSqWML5dEH6Mj_pls[gE=-I$BfmC`B1,(KQurkpXS,rUQ<5T`EBNa(kgWht5EW]"=ZV2fN522i=`JIkI62OIS2D]E?Mre%nDCl?6<\Qgif8.Mjl&s*FW-KX\:U_?>2H"gCpsO_2c.1)-EK4+W"mn(f5E0s^"@4]Ts$Bp%I;0JooSK)`R[,Rkr[9[<hbqYD&f!%mj,?9"(t&VNgI.e^$"&_,dQ+fp#LWAm7&b`R6qt?TF%O('7D[!:`oP]P#`h,?Umc^](@!30^"VC&PTJZfj4u15n8\q3?T,K,NZIn.)!cOi@UsRh132jGIO$/E8hcL:LHM%(7_>C_@q&(VG$4O1CpacLNq<!%bEhQE34m-SBWq$5cobQ\d5TQ(<n^iNZ,b8r1-J<\);kG(.Kp5jr.L'<l7I6`+0`jgkPhXR`HS.k+4f+;WW9$\t2TDKZUHT+!aGI\^i,^%;\(..^n0%mPaHGN;fpk?VZIVC!(;kBUR9_Yl.nl>AJiWm6.qn6V9nI.3B!9XCN6NT.btc:RS`g"6Fg;mJ~>endstream
+endobj
+10 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 264
+>>
+stream
+Gat%Z_+qm%&4H!cMK]2V$k=TN'dPc4?LSK8mA;=T]I7r'qY)84!Y2nCQIabm]pZ.\&'pQPlJU?8pM-rJY/*lX'_fV*RhWQQ4r/SGVqR?NXC=(c*ENWnP-/dH\=6iKn?dmt0\'=;T)[1+5"Hmc];>-+h[<(kFSN0A1:Vt"nusILOk^9Om;n278sD3LB=T>QGWDKQ**MMiAd/KD+.CAge[;ALYq`?/Qs7I,g6M$QKHP`g[_\S>'3'146a(K>rWP(Q#!+bRk5~>endstream
+endobj
+xref
+0 11
+0000000000 65535 f 
+0000000061 00000 n 
+0000000102 00000 n 
+0000000209 00000 n 
+0000000321 00000 n 
+0000000514 00000 n 
+0000000708 00000 n 
+0000000776 00000 n 
+0000001037 00000 n 
+0000001102 00000 n 
+0000001816 00000 n 
+trailer
+<<
+/ID 
+[<28c9aa324bdcb29741a9522844ac2db6><28c9aa324bdcb29741a9522844ac2db6>]
+% ReportLab generated PDF document -- digest (opensource)
+
+/Info 7 0 R
+/Root 6 0 R
+/Size 11
+>>
+startxref
+2171
+%%EOF

doc2md_lite-1.0.0/tests/test_lite.py

@@ -0,0 +1,53 @@
+import json, os, subprocess, sys, tempfile, unittest
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.join(HERE, "..")
+sys.path.insert(0, ROOT)
+import doc2md_lite as lite
+FX = os.path.join(HERE, "fixtures")
+CLI = os.path.join(ROOT, "doc2md_lite.py")
+
+
+class T(unittest.TestCase):
+    def cli(self, *args):
+        return subprocess.run([sys.executable, CLI, *args], capture_output=True, text=True)
+
+    def test_pdf(self):
+        md, info = lite.convert(os.path.join(FX, "store-report.pdf"))
+        self.assertTrue(md.startswith("# Spring Store Report"))
+        self.assertIn("| West | 15 | $61,300 |", md)
+        self.assertEqual(md.count("$61,300"), 1)
+        self.assertIn("- Check again in June.", md)
+        self.assertEqual(info["tables"], 1)
+
+    def test_html(self):
+        md, _ = lite.convert(os.path.join(FX, "returns-help.html"))
+        self.assertIn("# How returns work", md)
+        self.assertIn("| Gift card | 1 day |", md)
+        self.assertNotIn("console.log", md)
+        self.assertNotIn("Copyright", md)
+
+    def test_docx_refused(self):
+        with self.assertRaises(ValueError):
+            lite.convert("x.docx")
+
+    def test_cli_writes_file_and_json(self):
+        out = os.path.join(tempfile.mkdtemp(), "r.md")
+        r = self.cli(os.path.join(FX, "store-report.pdf"), "-o", out, "--json")
+        self.assertEqual(r.returncode, 0)
+        s = json.loads(r.stdout)
+        self.assertTrue(s["ok"]); self.assertEqual(s["tables"], 1)
+        self.assertIn("## Sales by region", open(out, encoding="utf-8").read())
+
+    def test_cli_stdout_and_no_tip_when_piped(self):
+        r = self.cli(os.path.join(FX, "returns-help.html"), "-o", "-")
+        self.assertTrue(r.stdout.startswith("# How returns work"))
+        self.assertNotIn("gumroad", r.stdout)
+
+    def test_cli_error(self):
+        r = self.cli("missing.pdf", "--json")
+        self.assertEqual(r.returncode, 1)
+        self.assertFalse(json.loads(r.stdout)["ok"])
+
+
+if __name__ == "__main__":
+    unittest.main()

doc2md_lite-1.0.0/tests/test_mcp.py

@@ -0,0 +1,37 @@
+"""Starts the MCP server over stdio, lists tools, and calls convert_to_markdown."""
+import asyncio, os, sys, unittest
+HERE = os.path.dirname(__file__)
+ROOT = os.path.join(HERE, "..")
+
+try:
+    from mcp import ClientSession, StdioServerParameters
+    from mcp.client.stdio import stdio_client
+except ImportError:
+    ClientSession = None
+
+
+async def _run():
+    params = StdioServerParameters(command=sys.executable, args=[os.path.join(ROOT, "doc2md_lite_mcp.py")], cwd=ROOT)
+    async with stdio_client(params) as (r, w):
+        async with ClientSession(r, w) as s:
+            await s.initialize()
+            tools = [t.name for t in (await s.list_tools()).tools]
+            res = await s.call_tool("convert_to_markdown", {"path": os.path.abspath(os.path.join(HERE, "fixtures", "store-report.pdf"))})
+            bad = await s.call_tool("convert_to_markdown", {"path": "/nope/missing.pdf"})
+            return tools, res, bad
+
+
+@unittest.skipIf(ClientSession is None, "mcp not installed")
+class MCP(unittest.TestCase):
+    def test_lists_and_calls_tool(self):
+        tools, res, bad = asyncio.run(_run())
+        self.assertEqual(tools, ["convert_to_markdown"])
+        self.assertFalse(res.isError)
+        text = " ".join(c.text for c in res.content if getattr(c, "type", "") == "text")
+        self.assertIn("# Spring Store Report", text)
+        self.assertIn("| North | 12 | $48,200 |", text)
+        self.assertTrue(bad.isError)
+
+
+if __name__ == "__main__":
+    unittest.main()