home / skills / daymade / claude-code-skills / markdown-tools

markdown-tools skill

/markdown-tools

This skill converts documents to high-quality markdown using quick or heavy mode, merging tools for best structure and imagery.

npx playbooks add skill daymade/claude-code-skills --skill markdown-tools

Review the files below or copy the command above to add this skill to your agents.

Files (9)
SKILL.md
4.9 KB
---
name: markdown-tools
description: Converts documents to markdown with multi-tool orchestration for best quality. Supports Quick Mode (fast, single tool) and Heavy Mode (best quality, multi-tool merge). Use when converting PDF/DOCX/PPTX files to markdown, extracting images from documents, validating conversion quality, or needing LLM-optimized document output.
---

# Markdown Tools

Convert documents to high-quality markdown with intelligent multi-tool orchestration.

## Dual Mode Architecture

| Mode | Speed | Quality | Use Case |
|------|-------|---------|----------|
| **Quick** (default) | Fast | Good | Drafts, simple documents |
| **Heavy** | Slower | Best | Final documents, complex layouts |

## Quick Start

### Installation

```bash
# Required: PDF/DOCX/PPTX support
uv tool install "markitdown[pdf]"
pip install pymupdf4llm
brew install pandoc
```

### Basic Conversion

```bash
# Quick Mode (default) - fast, single best tool
uv run --with pymupdf4llm --with markitdown scripts/convert.py document.pdf -o output.md

# Heavy Mode - multi-tool parallel execution with merge
uv run --with pymupdf4llm --with markitdown scripts/convert.py document.pdf -o output.md --heavy

# Check available tools
uv run scripts/convert.py --list-tools
```

## Tool Selection Matrix

| Format | Quick Mode Tool | Heavy Mode Tools |
|--------|----------------|------------------|
| PDF | pymupdf4llm | pymupdf4llm + markitdown |
| DOCX | pandoc | pandoc + markitdown |
| PPTX | markitdown | markitdown + pandoc |
| XLSX | markitdown | markitdown |

### Tool Characteristics

- **pymupdf4llm**: LLM-optimized PDF conversion with native table detection and image extraction
- **markitdown**: Microsoft's universal converter, good for Office formats
- **pandoc**: Excellent structure preservation for DOCX/PPTX

## Heavy Mode Workflow

Heavy Mode runs multiple tools in parallel and selects the best segments:

1. **Parallel Execution**: Run all applicable tools simultaneously
2. **Segment Analysis**: Parse each output into segments (tables, headings, images, paragraphs)
3. **Quality Scoring**: Score each segment based on completeness and structure
4. **Intelligent Merge**: Select best version of each segment across tools

### Merge Criteria

| Segment Type | Selection Criteria |
|--------------|-------------------|
| Tables | More rows/columns, proper header separator |
| Images | Alt text present, local paths preferred |
| Headings | Proper hierarchy, appropriate length |
| Lists | More items, nested structure preserved |
| Paragraphs | Content completeness |

## Image Extraction

```bash
# Extract images with metadata
uv run --with pymupdf scripts/extract_pdf_images.py document.pdf -o ./assets

# Generate markdown references file
uv run --with pymupdf scripts/extract_pdf_images.py document.pdf --markdown refs.md
```

Output:
- Images: `assets/img_page1_1.png`, `assets/img_page2_1.jpg`
- Metadata: `assets/images_metadata.json` (page, position, dimensions)

## Quality Validation

```bash
# Validate conversion quality
uv run --with pymupdf scripts/validate_output.py document.pdf output.md

# Generate HTML report
uv run --with pymupdf scripts/validate_output.py document.pdf output.md --report report.html
```

### Quality Metrics

| Metric | Pass | Warn | Fail |
|--------|------|------|------|
| Text Retention | >95% | 85-95% | <85% |
| Table Retention | 100% | 90-99% | <90% |
| Image Retention | 100% | 80-99% | <80% |

## Merge Outputs Manually

```bash
# Merge multiple markdown files
python scripts/merge_outputs.py output1.md output2.md -o merged.md

# Show segment attribution
python scripts/merge_outputs.py output1.md output2.md -o merged.md --verbose
```

## Path Conversion (Windows/WSL)

```bash
# Windows → WSL conversion
python scripts/convert_path.py "C:\Users\name\Documents\file.pdf"
# Output: /mnt/c/Users/name/Documents/file.pdf
```

## Common Issues

**"No conversion tools available"**
```bash
# Install all tools
pip install pymupdf4llm
uv tool install "markitdown[pdf]"
brew install pandoc
```

**FontBBox warnings during PDF conversion**
- Harmless font parsing warnings, output is still correct

**Images missing from output**
- Use Heavy Mode for better image preservation
- Or extract separately with `scripts/extract_pdf_images.py`

**Tables broken in output**
- Use Heavy Mode - it selects the most complete table version
- Or validate with `scripts/validate_output.py`

## Bundled Scripts

| Script | Purpose |
|--------|---------|
| `convert.py` | Main orchestrator with Quick/Heavy mode |
| `merge_outputs.py` | Merge multiple markdown outputs |
| `validate_output.py` | Quality validation with HTML report |
| `extract_pdf_images.py` | PDF image extraction with metadata |
| `convert_path.py` | Windows to WSL path converter |

## References

- `references/heavy-mode-guide.md` - Detailed Heavy Mode documentation
- `references/tool-comparison.md` - Tool capabilities comparison
- `references/conversion-examples.md` - Batch operation examples

Overview

This skill converts documents to high-quality Markdown using a dual-mode, multi-tool orchestration. I provide Quick Mode for fast, good-quality conversions and Heavy Mode for slower, highest-quality output that merges results from multiple tools. It handles PDFs, DOCX, PPTX (and some XLSX workflows), image extraction, and conversion validation.

How this skill works

The skill runs one or more conversion tools (pymupdf4llm, markitdown, pandoc) and parses each output into segments like headings, tables, images, lists, and paragraphs. In Quick Mode it uses the single best tool for speed; in Heavy Mode it runs tools in parallel, scores segments for completeness and structure, then intelligently merges the best segment versions into a single Markdown output. Additional scripts extract images with metadata, validate conversion quality, and allow manual merge/analysis.

When to use it

  • Convert PDFs, DOCX, or PPTX to Markdown for publishing or editing.
  • Extract images and metadata from PDFs for reuse or asset management.
  • Produce final, publication-ready Markdown using Heavy Mode when layout and tables must be exact.
  • Quick drafts and fast previews where speed matters more than perfect fidelity.
  • Validate or audit conversion quality with automated metrics and an HTML report.

Best practices

  • Start with Quick Mode to evaluate baseline output, then run Heavy Mode for final deliverables.
  • Install and enable the recommended tools for each format (pymupdf4llm, markitdown, pandoc) to maximize Heavy Mode coverage.
  • Run image extraction separately when you need original assets or higher-resolution images.
  • Use the validation script after conversion to check text/table/image retention and address weak segments.
  • When merging outputs manually, enable verbose attribution to see which tool produced each segment.

Example use cases

  • Convert a multipage research PDF into editable, structured Markdown with extracted figures and captions.
  • Migrate a DOCX report to Markdown while preserving headings, tables, and inline images for a static site generator.
  • Create a Markdown handout from a PPTX slideshow, extracting slide images and speaker notes.
  • Batch process technical docs: run Quick Mode for drafts, then Heavy Mode for final merges and validation.
  • Generate an HTML validation report to certify conversion quality for archival or compliance workflows.

FAQ

What formats are supported?

PDF, DOCX, PPTX are primary; XLSX is supported via markitdown for simple spreadsheets.

When should I use Heavy Mode?

Use Heavy Mode for final documents, complex layouts, or when tables/images must be preserved accurately.

How do I improve missing images or broken tables?

Enable Heavy Mode or run the image extraction script; validate outputs and re-run with additional tools installed.