• PDF files: Use pymupdf (fitz) for both text and visual extraction:
  1. Text extraction — extract all text from every page:
     bash

     PYTHONIOENCODING=utf-8 python -c "
     import fitz, sys
     doc = fitz.open(sys.argv[1])
     for i, page in enumerate(doc):
         text = page.get_text()
         if text.strip():
             print(f'=== PAGE {i+1} ===')
             print(text)
     " "<FILE_PATH>"

  2. Page rendering — render pages with diagrams, charts, or handwritten content as PNG images, then Read them visually (you are multimodal):
     bash

     python -c "
     import fitz, os, sys
     doc = fitz.open(sys.argv[1])
     out_dir = os.path.splitext(sys.argv[1])[0] + '_pages'
     os.makedirs(out_dir, exist_ok=True)
     for i, page in enumerate(doc):
         pix = page.get_pixmap(dpi=200)
         out = os.path.join(out_dir, f'page_{i+1:03d}.png')
         pix.save(out)
         print(out)
     " "<FILE_PATH>"

     Then use the Read tool on the rendered PNGs to see diagrams, formulas written in images, charts, and handwritten content. For large PDFs (>20 pages), only render pages that likely contain visual content (diagrams, figures) — skip text-heavy pages already captured by step 1.
  Combine text and visual information for full understanding.
• PPTX files: A

  .pptx

  is a zip archive containing XML slides and media. Use this two-step extraction process:
  1. Text extraction — run a Python script with

     python-pptx

     to parse all slides and extract text, tables, notes, and shape structure:
     bash

     PYTHONIOENCODING=utf-8 python -c "
     from pptx import Presentation
     import sys, os
     prs = Presentation(sys.argv[1])
     for i, slide in enumerate(prs.slides, 1):
         print(f'=== SLIDE {i} ===')
         for shape in slide.shapes:
             if shape.has_text_frame:
                 for para in shape.text_frame.paragraphs:
                     text = para.text.strip()
                     if text: print(text)
             if shape.has_table:
                 for row in shape.table.rows:
                     cells = [cell.text.strip() for cell in row.cells]
                     print(' | '.join(cells))
         if slide.has_notes_slide and slide.notes_slide.notes_text_frame:
             notes = slide.notes_slide.notes_text_frame.text.strip()
             if notes: print(f'[Notes: {notes}]')
     " "<FILE_PATH>"

  2. Image extraction — extract all images from the pptx media folder, then read them (you are multimodal and can see images directly):
     bash

     python -c "
     import zipfile, os, sys
     pptx_path = sys.argv[1]
     out_dir = os.path.splitext(pptx_path)[0] + '_media'
     os.makedirs(out_dir, exist_ok=True)
     with zipfile.ZipFile(pptx_path) as z:
         media = [n for n in z.namelist() if n.startswith('ppt/media/')]
         for m in media:
             data = z.read(m)
             fname = os.path.basename(m)
             with open(os.path.join(out_dir, fname), 'wb') as f:
                 f.write(data)
             print(os.path.join(out_dir, fname))
     " "<FILE_PATH>"

     Then use the Read tool on each extracted image — you can see diagrams, formulas, charts, and read text from images.
  Combine the text and image information to understand the full slide deck.
• Markdown / Text: Read directly
• Images (PNG/JPG): Read directly — you can see images, extract diagrams, formulas, tables from them

exam_focus

• ${CLAUDE_SKILL_DIR}/templates/cheatsheet_base.tex

• ${CLAUDE_SKILL_DIR}/examples/sample_output.tex

1. Use color-coded commands for everything:

   • \concept{term}

     — cyan, for key definitions and concepts

   • \process{term}

     — purple, for process names, algorithms, procedures

   • \category{term}

     — green, for classification labels, types, categories

   • \important{text}

     — yellow highlight, for critical formulas and must-know facts
   • Section titles (

     \section{}

     ) automatically render in deep blue
2. Extreme density formatting:
   • Use

     \\

     for line breaks, NOT

     \par

     or blank lines
   • Lists:

     \begin{itemize}...\end{itemize}

     (already configured for zero spacing)
   • No blank lines between content items — just

     \\

   • Abbreviate aggressively: thm, def, prop, iff, w/, s.t., wrt, WLOG, etc.
   • Section titles: ALL CAPS, 3-5 words max
3. Formulas — prevent column overflow:
   • Inline

     $...$

     for short formulas

   • \important{$formula$}

     for critical formulas (yellow background)
   • NEVER use

     \begin{equation}

     — wastes space
   • If a formula is too wide:

     \resizebox{\linewidth}{!}{$...$}

   • \important{}

     auto-wraps to column width (uses

     \parbox

     internally), so long text/formulas inside it will NOT overflow
   • For multi-line:

     aligned

     inside

     \[...\]

4. Tables: minimal padding:

   \begin{tabular}{@{}ll@{}}

   — zero extra padding
5. Theorems: write them out COMPLETELY. Don't abbreviate theorem statements. Use

   \important{}

   to highlight the theorem.
6. Detail level (from config):

   • concise

     : bullet points and formulas only, no prose

   • moderate

     : 1-2 sentence explanations, include intuition

   • detailed

     : derivation steps, edge cases, worked examples
7. Content toggles:

   • include_proofs

     : write proof sketches

   • include_examples

     : add concrete examples after definitions

   • include_derivations

     : show derivation steps
8. Organize by topic hierarchy, NOT by source file order. Group related concepts.

   exam_focus

   topics get the most space.
9. Fill the page completely. Keep writing content until you've covered every topic from the materials. If there's still space, add more examples, edge cases, or related concepts.
10. This compiles with XeLaTeX (because of

    fontspec

    ). Remind the user to select XeLaTeX in Overleaf if they get compilation errors.

<WORKDIR>/output/cheatsheet.tex

1. Wait for request (blocks until user acts):
   bash

   curl -s http://127.0.0.1:<PORT>/wait_for_request

   Use

   timeout: 600000

   .
2. If

   {"type": "quit"}

   → exit loop. If

   {"type": "request", "text": "...", "images": [...]}

   → process it.
3. Process: Read current tex, apply the change, write updated tex. If

   images

   array is non-empty, Read each image path — you are multimodal and can see the images. Use the visual information to inform your edits (e.g., user uploads a screenshot of a formula to add).
4. Post result (use Python to JSON-escape the tex):
   bash

   python -c "
   import json, sys
   with open('<WORKDIR>/output/cheatsheet.tex', 'r', encoding='utf-8') as f:
       tex = f.read()
   payload = json.dumps({'summary': '<SUMMARY>', 'tex': tex})
   sys.stdout.write(payload)
   " | curl -s -X POST http://127.0.0.1:<PORT>/result \
     -H "Content-Type: application/json" -d @-

5. Loop back to step 1.

rm -rf "<WORKDIR>/output/.rendered" "<WORKDIR>/output/.uploads" "<WORKDIR>/output/.converted"

*_media/

*_pages/

rm -rf <WORKDIR>/*_media <WORKDIR>/*_pages

Your cheatsheet is ready at

output/cheatsheet.tex

. Compile with XeLaTeX in Overleaf. Good luck on your exam!