# Doc Format Converter > Use this skill whenever the user asks to convert a document or file from one format to another — Markdown, HTML, PDF, Word (.docx), PowerPoint (.pptx), Excel (.xlsx), CSV, or plain text (e.g. "turn this Word doc into a PDF", "make slides from this markdown", "save this page as markdown"). Only for producing a converted file as a deliverable. Do NOT use this skill to answer questions about a document's content — the analyzing-* skills handle that. Run the bundled scripts/convert.py instead of writing ad-hoc conversion code, BEFORE attempting any conversion yourself. - Skill: `kody-w/doc-format-converter` (Agent Skill, multi-file: 12 files) - Install (CLI): `npx skillmds@latest add kody-w/doc-format-converter` - Raw SKILL.md: https://api.skillmd.com/api/skills/kody-w/doc-format-converter/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Web & Frontend - Author: kody-w (https://skillmd.com/u/kody-w) - Updated: 2026-09-17 - Page: https://skillmd.com/skills/kody-w/doc-format-converter --- Convert documents between formats using the bundled `scripts/convert.py`. It works fully offline with libraries already present in the sandbox (markitdown, mammoth, markdownify, reportlab, python-docx, python-pptx, pdfplumber, beautifulsoup4, magika) and routes each conversion through the highest-fidelity pipeline available. ## Division of labor with the analyzing-* skills This skill **produces files**; the built-in `analyzing-*` skills **answer questions**. Route accordingly: - "What does this PDF say?", "find X in this workbook", "summarize this deck" → use `analyzing-pdf` / `analyzing-xlsx` / `analyzing-pptx` etc., not this skill. In particular, never use `convert.py` as a substitute extraction path for PDF question-answering — `analyzing-pdf` owns that. - "Give me this as a PDF/Word doc/slides/markdown file" → this skill. - If the user asks content questions *after* a conversion, hand off to the matching `analyzing-*` skill on the original file rather than answering from this skill's intermediate output. - **Reuse their artifacts when present.** If an `analyzing-*` preprocessor has already produced a `converted.md` for the source file, feed that to `convert.py` as Markdown input (`convert.py converted.md --to pptx`) instead of re-extracting the original — it is a high-quality extraction with page markers and pipe tables. ## Instructions 1. Identify the input file and the target format the user wants. Targets: `md`, `html`, `pdf`, `docx`, `pptx`, `txt`. Inputs additionally include `xlsx` and `csv`. 2. Run the converter by the script's path inside this skill's folder — typically `/app/skills/doc-format-converter/` — so it works regardless of the current working directory: ```bash python /app/skills/doc-format-converter/scripts/convert.py INPUT --to FORMAT [-o OUTPUT] ``` It prints the output path on success. If `-o` is omitted, the output lands next to the input with the new extension. 3. For a folder of files, use batch mode and share the printed summary table with the user: ```bash python /app/skills/doc-format-converter/scripts/convert.py --batch DIR --to FORMAT [--out-dir DIR] ``` 4. If the script reports an unsupported conversion, relay its message — it prints the full support matrix. Offer the nearest supported route (e.g. PDF → slides is unsupported; offer PDF → Markdown, let the user edit, then Markdown → PPTX). 5. If the script warns that a file's extension doesn't match its content (content sniffing via magika), tell the user; the converter proceeds using the detected content type. 6. Return the converted file to the user and briefly state which pipeline was used (e.g. "docx → HTML via mammoth"). ## Conversion notes - Markdown is the universal intermediate: Office/PDF inputs are extracted with markitdown, then re-rendered. Some layout (columns, images, footnotes) is simplified — say so when converting layout-heavy documents. - For **scanned/image PDFs**, this skill's pdf → md route extracts little or nothing. Run the `analyzing-pdf` preprocessor instead (its OCR pipeline is the better extractor) and feed its text artifact into this skill's renderers. - PDF output registers a CJK-capable font automatically (bundled Noto CJK fonts, falling back to reportlab's built-in CID fonts), so Chinese, Japanese, and Korean text renders correctly. - PPTX output builds one slide per `#`/`##` heading with body content as bullets, overflowing onto continuation slides — it is an outline deck, not finished design. - `pdf → pptx` and `pptx → pdf/docx` are deliberately unsupported: the extraction is too lossy to present as a finished conversion. ## Guardrails - Never fabricate or "fill in" content the source file does not contain; if extraction returns nothing, report that instead of inventing text. - Do not hand-write conversion code when `convert.py` supports the pair; only fall back to custom code if the script fails, and say that you did. - Never claim a conversion succeeded without the script's success output. - Verification test cases live in `references/test-cases.md` with fixtures in `assets/samples/` — use them when the user asks to validate the skill. ## Run this — do not improvise This capability's deterministic implementation is a RAPP single-file agent, linked beside this file as `doc_format_converter_agent.py` and embedded as the fenced Python below (sha256 89c224c39e622d0f…; a byte-exact copy is also vaulted in the capsule comment at the end of this file). On a host with sandbox execution, run the linked file directly — if it is missing, write the fence contents verbatim to `doc_format_converter_agent.py` first: ```bash python3 doc_format_converter_agent.py '{"key": "value"}' # arguments as one JSON object echo '{"key": "value"}' | python3 doc_format_converter_agent.py # or on stdin python3 doc_format_converter_agent.py --tool # emit the JSON tool contract ``` Treat stdout as a tool result. If it reports missing or unresolved inputs, stop and collect them. If it returns `steps`, execute those steps in order exactly as returned; if it returns `instructions`, follow them with the supplied inputs. Otherwise use the result verbatim. Do not invent behavior beyond that output. On a host without code execution, treat the Parameters schema and the code below as the exact specification and never paraphrase a step. Never edit inside the generated markers; a converter-equipped host can instead restore the original file checksum-verified with the installed `rapp-agent-converter/scripts/toast.py convert SKILL.md --to agent`. ````python # rapp:deterministic """DocFormatConverter -- Use this skill whenever the user asks to convert a document or file from one format to another — Markdown, HTML, PDF, Word (.docx), PowerPoint (.pptx), Excel (.xlsx), CSV, or plain text (e.g. "turn this Word doc into a PDF", "make slides from this markdown", "save this page as markdown"). Only for producing a converted file as a deliverable. Do NOT use this skill to answer questions about a document's content — the analyzing-* skills handle that. Run the bundled scripts/convert.py instead of writing ad-hoc conversion code, BEFORE attempting any conversion yourself. Generated by the rapp skill from doc-format-converter. The RCI capsule at the bottom of this file carries the full original; `toast.py convert` restores it byte-exact.""" import json import re import sys try: from agents.basic_agent import BasicAgent except ImportError: # running OUTSIDE a brainstem -- stay executable anyway. class BasicAgent: # noqa: D101 - minimal stand-in, same contract def __init__(self, name=None, metadata=None): if name: self.name = name if metadata: self.metadata = metadata def perform(self, **kwargs): return "Not implemented." def system_context(self): return None def to_tool(self): return {"type": "function", "function": { "name": self.name, "description": self.metadata.get("description", ""), "parameters": self.metadata.get("parameters", {})}} # The procedural layer, verbatim from the source capability. INSTRUCTIONS = 'Convert documents between formats using the bundled `scripts/convert.py`. It\nworks fully offline with libraries already present in the sandbox\n(markitdown, mammoth, markdownify, reportlab, python-docx, python-pptx,\npdfplumber, beautifulsoup4, magika) and routes each conversion through the\nhighest-fidelity pipeline available.\n\n## Division of labor with the analyzing-* skills\n\nThis skill **produces files**; the built-in `analyzing-*` skills **answer\nquestions**. Route accordingly:\n\n- "What does this PDF say?", "find X in this workbook", "summarize this\n deck" → use `analyzing-pdf` / `analyzing-xlsx` / `analyzing-pptx` etc.,\n not this skill. In particular, never use `convert.py` as a substitute\n extraction path for PDF question-answering — `analyzing-pdf` owns that.\n- "Give me this as a PDF/Word doc/slides/markdown file" → this skill.\n- If the user asks content questions *after* a conversion, hand off to the\n matching `analyzing-*` skill on the original file rather than answering\n from this skill's intermediate output.\n- **Reuse their artifacts when present.** If an `analyzing-*` preprocessor\n has already produced a `converted.md` for the source file, feed that to\n `convert.py` as Markdown input (`convert.py converted.md --to pptx`)\n instead of re-extracting the original — it is a high-quality extraction\n with page markers and pipe tables.\n\n## Instructions\n\n1. Identify the input file and the target format the user wants. Targets:\n `md`, `html`, `pdf`, `docx`, `pptx`, `txt`. Inputs additionally include\n `xlsx` and `csv`.\n2. Run the converter by the script's path inside this skill's folder —\n typically `/app/skills/doc-format-converter/` — so it works regardless of\n the current working directory:\n\n ```bash\n python /app/skills/doc-format-converter/scripts/convert.py INPUT --to FORMAT [-o OUTPUT]\n ```\n\n It prints the output path on success. If `-o` is omitted, the output lands\n next to the input with the new extension.\n3. For a folder of files, use batch mode and share the printed summary table\n with the user:\n\n ```bash\n python /app/skills/doc-format-converter/scripts/convert.py --batch DIR --to FORMAT [--out-dir DIR]\n ```\n\n4. If the script reports an unsupported conversion, relay its message — it\n prints the full support matrix. Offer the nearest supported route (e.g.\n PDF → slides is unsupported; offer PDF → Markdown, let the user edit, then\n Markdown → PPTX).\n5. If the script warns that a file's extension doesn't match its content\n (content sniffing via magika), tell the user; the converter proceeds using\n the detected content type.\n6. Return the converted file to the user and briefly state which pipeline was\n used (e.g. "docx → HTML via mammoth").\n\n## Conversion notes\n\n- Markdown is the universal intermediate: Office/PDF inputs are extracted with\n markitdown, then re-rendered. Some layout (columns, images, footnotes) is\n simplified — say so when converting layout-heavy documents.\n- For **scanned/image PDFs**, this skill's pdf → md route extracts little or\n nothing. Run the `analyzing-pdf` preprocessor instead (its OCR pipeline is\n the better extractor) and feed its text artifact into this skill's\n renderers.\n- PDF output registers a CJK-capable font automatically (bundled Noto CJK\n fonts, falling back to reportlab's built-in CID fonts), so Chinese,\n Japanese, and Korean text renders correctly.\n- PPTX output builds one slide per `#`/`##` heading with body content as\n bullets, overflowing onto continuation slides — it is an outline deck, not\n finished design.\n- `pdf → pptx` and `pptx → pdf/docx` are deliberately unsupported: the\n extraction is too lossy to present as a finished conversion.\n\n## Guardrails\n\n- Never fabricate or "fill in" content the source file does not contain; if\n extraction returns nothing, report that instead of inventing text.\n- Do not hand-write conversion code when `convert.py` supports the pair; only\n fall back to custom code if the script fails, and say that you did.\n- Never claim a conversion succeeded without the script's success output.\n- Verification test cases live in `references/test-cases.md` with fixtures in\n `assets/samples/` — use them when the user asks to validate the skill.' # Ordered commands lifted verbatim from the capability's own documentation. STEPS = [] class DocFormatConverterAgent(BasicAgent): def __init__(self): self.name = 'DocFormatConverter' self.metadata = { "name": "DocFormatConverter", "description": "Use this skill whenever the user asks to convert a document or file from one format to another \u2014 Markdown, HTML, PDF, Word (.docx), PowerPoint (.pptx), Excel (.xlsx), CSV, or plain text (e.g. \"turn this Word doc into a PDF\", \"make slides from this markdown\", \"save this page as markdown\"). Only for producing a converted file as a deliverable. Do NOT use this skill to answer questions about a document's content \u2014 the analyzing-* skills handle that. Run the bundled scripts/convert.py instead of writing ad-hoc conversion code, BEFORE attempting any conversion yourself.", "parameters": { "type": "object", "properties": {}, "required": [] } } super().__init__(name=self.name, metadata=self.metadata) def perform(self, **kwargs): # toaster:generated-perform return json.dumps({"status": "ok", "instructions": INSTRUCTIONS, "inputs": kwargs, "note": "Prose-only capability: follow INSTRUCTIONS " "with the given inputs."}, indent=2) if __name__ == "__main__": # echo '{"arg": "value"}' | python3 doc_format_converter_agent.py # python3 doc_format_converter_agent.py '{"arg": "value"}' # python3 doc_format_converter_agent.py --tool # emit the JSON tool contract _a = sys.argv[1:] if _a and _a[0] == "--tool": print(json.dumps(DocFormatConverterAgent().to_tool(), indent=2)) else: _raw = _a[0] if _a else (sys.stdin.read().strip() or "{}") print(DocFormatConverterAgent().perform(**json.loads(_raw))) # rci-capsule:v1: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 ````