doc-ingest

name	doc-ingest
description	Read existing documents (PDF, Word, PowerPoint, Excel, HTML) and convert them into clean Markdown/plain text the agent can reason over: extract text, ingest a file, summarize a document. Use whenever the user wants to READ, extract, ingest, transcribe, or summarize the contents of an existing file (not create one).
license	MIT (Code Buddy original skill)
nativeEngine	{"triggers":["extract text","convert to markdown","to markdown","markdown","ingest","read this file","read document","summarize","résume","résumé","extrais","transcribe","ocr"]}

Ingest existing documents into Markdown / text

Turn a document the user already has (PDF, Word, PowerPoint, Excel, HTML) into clean Markdown or plain text so you can quote, summarize, or transform it. This is the read counterpart to the create skills (xlsx/docx/pptx/pdf).

Work one visible step at a time and verify before reporting.

Two backends — prefer the lean one

• Lean (always available, no extra install): the bundled libraries pypdf, python-docx, python-pptx, openpyxl read the common Office/PDF formats with python3 -c "import pypdf, docx, pptx, openpyxl". Use this path by default.
• Rich (optional, prepare:python:extras): markitdown adds HTML, images (OCR), EPUB, ZIP and more, and emits tidy Markdown directly. Only reach for it when the lean path can't read the format.

Workflow (one step at a time)

1. Identify the file and its type (extension).
2. Extract: run a short Python script (heredoc via the bash tool) that reads the file with the matching library and prints — or writes — Markdown/text.
3. Verify: assert the output is non-empty (e.g. assert len(text) > 0) and print a length + first lines so the extraction is visibly correct.
4. Report: the extracted text (or the saved .md path) and a one-line summary.

Lean extraction (covers PDF / Word / PowerPoint / Excel)

python3 - "$FILE" <<'PY'
import sys, os
src = sys.argv[1]
ext = os.path.splitext(src)[1].lower()

def pdf(p):
    from pypdf import PdfReader
    return "\n\n".join((pg.extract_text() or "") for pg in PdfReader(p).pages)

def docx(p):
    import docx
    d = docx.Document(p)
    return "\n".join(par.text for par in d.paragraphs)

def pptx(p):
    from pptx import Presentation
    out = []
    for i, sl in enumerate(Presentation(p).slides, 1):
        out.append(f"## Slide {i}")
        for sh in sl.shapes:
            if sh.has_text_frame:
                out.append(sh.text_frame.text)
    return "\n".join(out)

def xlsx(p):
    from openpyxl import load_workbook
    wb = load_workbook(p, data_only=True)
    out = []
    for ws in wb.worksheets:
        out.append(f"## {ws.title}")
        for row in ws.iter_rows(values_only=True):
            out.append(" | ".join("" if c is None else str(c) for c in row))
    return "\n".join(out)

handlers = {".pdf": pdf, ".docx": docx, ".pptx": pptx, ".xlsx": xlsx}
fn = handlers.get(ext)
if not fn:
    sys.exit(f"Lean path can't read {ext}; enable the rich backend (prepare:python:extras) for markitdown.")
text = fn(src)
assert text and text.strip(), "extraction produced no text"
print(f"[{len(text)} chars]")
print("\n".join(text.splitlines()[:40]))
PY

Rich backend (markitdown — optional)

python3 - <<'PY'
try:
    from markitdown import MarkItDown
except ModuleNotFoundError:
    raise SystemExit(
        "markitdown not installed. Run `npm run prepare:python:extras` in cowork/ "
        "to add the optional ingestion backend (HTML, images/OCR, EPUB, ...)."
    )
md = MarkItDown()
res = md.convert("INPUT_PATH")
assert res.text_content, "markitdown produced no content"
print(res.text_content[:4000])
PY

Notes

• Never invent content — only report what the extractor returned.
• For large files, summarize after extraction rather than dumping everything.
• To then produce a new document from what you read, hand off to the xlsx/docx/pptx/pdf create skills.