medsci-skills 4.1.0

package/skills/present-paper/references/workflow-checklist.md

@@ -0,0 +1,109 @@
+# Presentation Preparation Checklist
+
+Use this checklist to verify completeness at each phase.
+
+---
+
+## Phase 0: Init & Outline
+
+### Paper Analysis
+- [ ] Full citation with DOI/PMID recorded
+- [ ] Background gap clearly identified
+- [ ] Study design classified (RCT, cohort, case series, etc.)
+- [ ] Sample size and key inclusion/exclusion criteria noted
+- [ ] Primary and secondary outcomes listed
+- [ ] Key results with effect sizes and confidence intervals
+- [ ] Limitations enumerated (minimum 3)
+- [ ] Clinical/scientific significance stated
+
+### Audience Assessment
+- [ ] Target audience specialties identified
+- [ ] Knowledge level estimated (student / trainee / specialist / mixed)
+- [ ] Specialty-specific terms that need plain-language explanation listed
+- [ ] Prior session topics noted (for coursework presentations)
+
+### Outline
+- [ ] Slide count matches presentation time (roughly 1 slide per minute)
+- [ ] Time allocated per slide
+- [ ] Narrative arc: context → gap → methods → results → implications
+- [ ] Opening connects to audience's existing knowledge
+- [ ] Closing has clear take-home messages (3-5 maximum)
+
+---
+
+## Phase 1: Supporting Research
+
+### Search Completeness
+- [ ] Follow-up studies searched (has finding been replicated?)
+- [ ] Contradicting evidence searched (balance for Q&A)
+- [ ] Review articles checked (authoritative framing)
+- [ ] Clinical trial data checked (real-world context)
+
+### Citation Verification
+- [ ] Every reference has DOI or PMID
+- [ ] No fabricated citations
+- [ ] Unverifiable references marked [UNVERIFIED]
+
+### Data Extraction
+- [ ] Only presentation-relevant data extracted (not full paper summaries)
+- [ ] Data source (reference number) linked to each statistic
+- [ ] Numbers cross-checked against original papers
+
+---
+
+## Phase 2: Script & Content
+
+### Audience Adaptation
+- [ ] Technical terms explained at appropriate depth for audience
+- [ ] Mixed-audience terms have one-line plain-language additions
+- [ ] No unexplained abbreviations on first use
+- [ ] Pronunciation guides for drug names and key abbreviations
+
+### Script Quality
+- [ ] Script matches allocated time (130-150 words/min for academic talks)
+- [ ] Transitions between slides are explicit
+- [ ] Opening hooks audience attention
+- [ ] Closing reinforces key messages
+- [ ] Limitations acknowledged honestly (not hidden)
+
+### Optional Extension
+- [ ] Extension section included only if user requested
+- [ ] Extension connects naturally to main content
+- [ ] Extension has concrete evidence (not speculation)
+
+---
+
+## Phase 3: Slides & Notes
+
+### Note Injection
+- [ ] Notes mapped to correct slide numbers
+- [ ] Slide content NOT modified (only notes pane)
+- [ ] Script verified by running inject script on a copy first
+- [ ] Output file opened and spot-checked in presentation software
+
+### Content Consistency
+- [ ] Numbers in notes match numbers on slides
+- [ ] If slides round numbers (e.g., 12% vs 10.9%), notes use precise values
+- [ ] Slide titles match script section references
+
+---
+
+## Phase 4: Q&A Preparation
+
+### Question Coverage
+- [ ] Methodology questions (study design choices, limitations)
+- [ ] Domain expert questions (deep technical details)
+- [ ] Generalist questions (clinical relevance, so-what)
+- [ ] Student questions (concept clarification)
+
+### Answer Quality
+- [ ] Each answer follows: Acknowledge → Evidence → Conclude
+- [ ] Limitations acknowledged, not deflected
+- [ ] Supporting evidence cited with author/year
+- [ ] Answers are concise (30-60 seconds speaking time each)
+
+### Quick Review Sheet
+- [ ] Key numbers in a single table
+- [ ] Common confusion points listed
+- [ ] Classification frameworks distinguished (if multiple exist)
+- [ ] Precise values noted where slides use rounded numbers

package/skills/present-paper/scripts/extract_pdf_figures.py

@@ -0,0 +1,243 @@
+#!/usr/bin/env python3
+"""Extract figures from PDF pages via pdftoppm + PIL crop (normalized box coords).
+
+Two usage modes:
+
+1. **CLI single-crop**: extract one or more figures from specific pages of a PDF
+   using normalized (0–1) crop boxes.
+
+       extract_pdf_figures.py paper.pdf \\
+           --page 5 --crop 0.10,0.05,0.95,0.55 --out fig01.png
+
+       extract_pdf_figures.py paper.pdf \\
+           --pages 5,6 \\
+           --crops "0.10,0.05,0.95,0.55;0.05,0.05,0.95,0.50" \\
+           --out fig01.png,fig02.png
+
+2. **YAML config batch**: extract many figures across multiple PDFs declaratively.
+
+       extract_pdf_figures.py --config figures.yaml --out-dir extracted/
+
+   YAML schema:
+
+       dpi: 250                          # default 250; override per item with item.dpi
+       pdf_dir: /abs/path/to/pdfs/       # optional base path resolved per item.pdf
+       items:
+         - name: fig01_concept_overview
+           pdf: 01_paper.pdf             # joined with pdf_dir if relative
+           page: 4                       # 1-indexed
+           crop: [0.06, 0.08, 0.97, 0.52]  # [left, top, right, bottom] normalized
+           caption: "Conceptual overview (Author YYYY Fig 1)"  # optional, only logged
+
+Requires: pdftoppm (poppler-utils — `brew install poppler`), Pillow.
+Optional: PyYAML for --config mode (`pip install pyyaml`).
+
+Cross-references:
+  - /present-paper Phase 3 (Slides & Notes)
+  - references/slide_visual_styles/nature_lancet.md §5 (figure handling)
+  - ~/.claude/rules/pptx-mac-compatibility.md §7 (Inches EMU pitfall)
+"""
+from __future__ import annotations
+
+import argparse
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Iterable
+
+try:
+    from PIL import Image
+except ImportError:
+    sys.stderr.write("ERROR: Pillow is required. Install: pip install Pillow\n")
+    raise
+
+
+def _parse_crop(s: str) -> tuple[float, float, float, float]:
+    """Parse 'l,t,r,b' string into normalized box tuple. Validates 0 <= l<r <=1, t<b."""
+    parts = s.split(",")
+    if len(parts) != 4:
+        raise ValueError(f"crop must be 4 comma-separated floats, got: {s!r}")
+    l, t, r, b = (float(x) for x in parts)
+    for label, v in (("left", l), ("top", t), ("right", r), ("bottom", b)):
+        if not 0.0 <= v <= 1.0:
+            raise ValueError(f"crop {label}={v} not in [0,1]")
+    if not (l < r and t < b):
+        raise ValueError(f"crop must satisfy left<right and top<bottom; got {s!r}")
+    return (l, t, r, b)
+
+
+def _render_page(pdf: Path, page: int, dpi: int, tmp_dir: Path) -> Path:
+    """Render a single PDF page to PNG using pdftoppm; return resulting file path."""
+    if not pdf.exists():
+        raise FileNotFoundError(f"PDF not found: {pdf}")
+    out_prefix = tmp_dir / f"page_{page}"
+    cmd = [
+        "pdftoppm",
+        "-png",
+        "-r", str(dpi),
+        "-f", str(page),
+        "-l", str(page),
+        str(pdf),
+        str(out_prefix),
+    ]
+    proc = subprocess.run(cmd, capture_output=True, text=True)
+    if proc.returncode != 0:
+        raise RuntimeError(
+            f"pdftoppm failed for {pdf.name} page {page}:\n{proc.stderr.strip()}"
+        )
+    # pdftoppm writes "<prefix>-<padded_page>.png" — width varies with total pages.
+    matches = sorted(tmp_dir.glob(f"page_{page}-*.png"))
+    if not matches:
+        raise RuntimeError(
+            f"pdftoppm produced no output for {pdf.name} page {page} "
+            f"(expected page_{page}-*.png in {tmp_dir})"
+        )
+    return matches[0]
+
+
+def _crop_image(src: Path, box: tuple[float, float, float, float], dst: Path) -> tuple[int, int]:
+    """Crop src image by normalized box and save to dst. Returns (w, h) of cropped image."""
+    img = Image.open(src)
+    W, H = img.size
+    l, t, r, b = box
+    cropped = img.crop((int(W * l), int(H * t), int(W * r), int(H * b)))
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    cropped.save(dst, "PNG", optimize=True)
+    return cropped.size
+
+
+def extract_one(pdf: Path, page: int, crop: tuple[float, float, float, float],
+                out: Path, dpi: int = 250) -> Path:
+    """Single-figure extraction. Returns the output path."""
+    with tempfile.TemporaryDirectory() as td:
+        page_png = _render_page(pdf, page, dpi, Path(td))
+        w, h = _crop_image(page_png, crop, out)
+        print(f"OK  {out.name:50s}  ({w}x{h})  {pdf.name} page {page}")
+    return out
+
+
+def extract_batch(items: Iterable[dict], out_dir: Path, default_dpi: int = 250,
+                   pdf_dir: Path | None = None) -> list[Path]:
+    """Batch extraction from YAML config. Caches rendered pages per (pdf, page, dpi).
+
+    Each item dict accepts:
+      name (str, required): output filename stem (.png appended)
+      pdf  (str, required): PDF path (joined with pdf_dir if relative)
+      page (int, required): 1-indexed PDF page number
+      crop (list[float], required): [left, top, right, bottom] normalized
+      dpi  (int, optional): override default_dpi
+      caption (str, optional): logged only
+    """
+    out_dir = Path(out_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    results: list[Path] = []
+    with tempfile.TemporaryDirectory() as td:
+        td_path = Path(td)
+        cache: dict[tuple[str, int, int], Path] = {}
+        for item in items:
+            try:
+                name = item["name"]
+                pdf_str = item["pdf"]
+                page = int(item["page"])
+                crop = tuple(float(x) for x in item["crop"])
+                if len(crop) != 4:
+                    raise ValueError("crop must have 4 elements")
+                dpi = int(item.get("dpi", default_dpi))
+            except (KeyError, ValueError, TypeError) as e:
+                print(f"SKIP item {item!r}: {e}")
+                continue
+
+            pdf = Path(pdf_str)
+            if pdf_dir is not None and not pdf.is_absolute():
+                pdf = pdf_dir / pdf
+
+            cache_key = (str(pdf), page, dpi)
+            if cache_key not in cache:
+                try:
+                    cache[cache_key] = _render_page(pdf, page, dpi, td_path)
+                except (FileNotFoundError, RuntimeError) as e:
+                    print(f"SKIP {name}: {e}")
+                    continue
+
+            dst = out_dir / f"{name}.png"
+            try:
+                w, h = _crop_image(cache[cache_key], crop, dst)
+            except ValueError as e:
+                print(f"SKIP {name}: {e}")
+                continue
+
+            caption = item.get("caption", "")
+            tail = f"  {caption}" if caption else ""
+            print(f"OK  {dst.name:50s}  ({w}x{h})  {pdf.name} page {page}{tail}")
+            results.append(dst)
+
+    print(f"\nTotal: {len(results)} figures in {out_dir}")
+    return results
+
+
+def _cli() -> int:
+    p = argparse.ArgumentParser(
+        description="Extract figures from PDF pages (pdftoppm + PIL crop).",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    p.add_argument("pdf", nargs="?", help="PDF input (single-crop mode); omit for --config mode")
+    p.add_argument("--page", type=int, help="single-crop: 1-indexed page number")
+    p.add_argument("--pages", help="single-crop: comma-separated pages (paired with --crops)")
+    p.add_argument("--crop", help="single-crop: 'l,t,r,b' normalized box")
+    p.add_argument("--crops", help="single-crop: ';'-separated 'l,t,r,b' boxes paired with --pages")
+    p.add_argument("--out", help="single-crop: output path (or comma-separated paths)")
+    p.add_argument("--out-dir", help="batch mode: output directory")
+    p.add_argument("--dpi", type=int, default=250, help="render DPI (default 250)")
+    p.add_argument("--config", help="batch mode: YAML config path")
+    args = p.parse_args()
+
+    # Batch (YAML) mode
+    if args.config:
+        try:
+            import yaml  # type: ignore
+        except ImportError:
+            sys.stderr.write("ERROR: --config requires PyYAML. Install: pip install pyyaml\n")
+            return 2
+        cfg_path = Path(args.config)
+        if not cfg_path.exists():
+            sys.stderr.write(f"ERROR: config not found: {cfg_path}\n")
+            return 2
+        cfg = yaml.safe_load(cfg_path.read_text()) or {}
+        items = cfg.get("items", [])
+        out_dir = Path(args.out_dir or cfg.get("out_dir", "extracted"))
+        dpi = int(args.dpi if args.dpi != 250 else cfg.get("dpi", 250))
+        pdf_dir = cfg.get("pdf_dir")
+        pdf_dir = Path(pdf_dir) if pdf_dir else None
+        extract_batch(items, out_dir, default_dpi=dpi, pdf_dir=pdf_dir)
+        return 0
+
+    # Single-crop mode (single or paired)
+    if not args.pdf:
+        p.error("pdf positional argument required for single-crop mode (or use --config)")
+    pdf = Path(args.pdf)
+
+    if args.crops or args.pages:
+        if not (args.crops and args.pages and args.out):
+            p.error("--pages, --crops, and --out must all be set together")
+        pages = [int(x) for x in args.pages.split(",")]
+        crops = [_parse_crop(c) for c in args.crops.split(";")]
+        outs = [Path(o.strip()) for o in args.out.split(",")]
+        if not (len(pages) == len(crops) == len(outs)):
+            p.error(
+                f"counts mismatch: {len(pages)} pages, {len(crops)} crops, {len(outs)} outs"
+            )
+        for pg, cb, op in zip(pages, crops, outs):
+            extract_one(pdf, pg, cb, op, dpi=args.dpi)
+        return 0
+
+    if not (args.page is not None and args.crop and args.out):
+        p.error("single crop requires --page, --crop, --out")
+    box = _parse_crop(args.crop)
+    extract_one(pdf, args.page, box, Path(args.out), dpi=args.dpi)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(_cli())

package/skills/present-paper/scripts/inject_pronunciation_notes.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+"""Append a pronunciation guide section to every slide's speaker notes.
+
+Designed for non-native presenters who want a per-slide reading reference
+without affecting the audience-facing view. Scans each slide's notes text
+for tokens defined in a YAML/JSON ``PRON_DICT`` file (term → reading +
+full-name), uses word-boundary regex to avoid false positives, and writes
+a "[ 발음 ]" (or user-defined) section at the bottom of the notes.
+
+Also auto-matches allele-style tokens (HLA-DRB1*07:01, HLA-A*02:01, …)
+that match a configurable regex and synthesizes a reading by combining
+the base reading from PRON_DICT with "스타 NN콜론NN".
+
+This script is invocation-agnostic: it modifies a PPTX in place (or to a
+new path) and does not assume any specific lecture topic. The PRON_DICT
+file is supplied by the caller and is the only language/domain config.
+
+Usage
+-----
+
+PRON_DICT is YAML or JSON. Each key is the term as it appears in the
+notes text. Each value is a 2-tuple [reading, full_name].
+
+```yaml
+# pron_dict.yaml
+GWAS: ["지와스", "Genome-wide association study"]
+HLA: ["에이치-엘-에이", "Human leukocyte antigen"]
+LGI1: ["엘-지-아이-원", "Leucine-rich glioma-inactivated 1"]
+Perriot: ["페리오", "프랑스, t 묵음"]
+```
+
+```bash
+python3 inject_pronunciation_notes.py input.pptx output.pptx \
+    --dict pron_dict.yaml --header "[ 발음 ]"
+```
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import shutil
+import sys
+from pathlib import Path
+
+from pptx import Presentation
+from pptx.util import Pt
+
+DEFAULT_ALLELE_RE = r"\b(?:HLA-)?[A-Z]{1,5}[0-9]?\*[0-9]{2}:[0-9]{2}(?:N|L|S|Q)?\b"
+DEFAULT_HEADER = "[ Pronunciation ]"
+
+
+def load_dict(path: Path) -> dict:
+    if path.suffix.lower() in (".yaml", ".yml"):
+        try:
+            import yaml  # type: ignore
+        except ImportError:
+            raise SystemExit("PyYAML required for YAML dict; pip install pyyaml")
+        with path.open() as f:
+            raw = yaml.safe_load(f)
+    elif path.suffix.lower() == ".json":
+        with path.open() as f:
+            raw = json.load(f)
+    else:
+        raise SystemExit(f"unsupported dict format: {path.suffix}")
+    out = {}
+    for term, value in raw.items():
+        if isinstance(value, (list, tuple)) and len(value) >= 1:
+            reading = value[0]
+            fullname = value[1] if len(value) > 1 else ""
+        elif isinstance(value, str):
+            reading, fullname = value, ""
+        else:
+            continue
+        out[term] = (reading, fullname)
+    return out
+
+
+def find_terms(text: str, pron_dict: dict, allele_re: str | None):
+    """Return [(term, reading, fullname)] for every dict key appearing in *text*."""
+    if not text:
+        return []
+    hits = []
+    seen = set()
+    for term, (reading, fullname) in pron_dict.items():
+        pat = r"(?<![A-Za-z0-9_])" + re.escape(term) + r"(?![A-Za-z0-9_])"
+        if re.search(pat, text):
+            if term not in seen:
+                hits.append((term, reading, fullname))
+                seen.add(term)
+    if allele_re:
+        allele_pattern = re.compile(allele_re)
+        alleles = sorted(set(allele_pattern.findall(text)))
+        for a in alleles:
+            if a in seen:
+                continue
+            base = a.replace("HLA-", "").split("*")[0]
+            tail = a.split("*", 1)[1] if "*" in a else ""
+            base_reading = pron_dict.get(base, (base.lower(), ""))[0]
+            reading = f"{base_reading} star {tail.replace(':', ' colon ')}"
+            hits.append((a, reading, "HLA allele"))
+            seen.add(a)
+    return hits
+
+
+def inject_notes(slide, terms, header: str):
+    if not terms:
+        return False
+    tf = slide.notes_slide.notes_text_frame
+
+    # blank separator
+    p = tf.add_paragraph()
+    r = p.add_run(); r.text = " "
+    r.font.size = Pt(11)
+
+    # header
+    p = tf.add_paragraph()
+    r = p.add_run(); r.text = header
+    r.font.bold = True
+    r.font.size = Pt(12)
+
+    # each term: "▪ term  —  reading  ·  fullname"
+    for term, reading, fullname in terms:
+        p = tf.add_paragraph()
+        r = p.add_run(); r.text = f"▪ {term}"
+        r.font.bold = True
+        r.font.size = Pt(11)
+        r2 = p.add_run(); r2.text = f"  —  {reading}"
+        r2.font.size = Pt(11)
+        if fullname:
+            r3 = p.add_run(); r3.text = f"  ·  {fullname}"
+            r3.font.italic = True
+            r3.font.size = Pt(11)
+    return True
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("src", type=Path)
+    ap.add_argument("dst", type=Path)
+    ap.add_argument("--dict", required=True, type=Path,
+                    help="path to pron_dict.yaml or pron_dict.json")
+    ap.add_argument("--header", default=DEFAULT_HEADER,
+                    help="section header text (default: %(default)s)")
+    ap.add_argument("--allele-regex", default=DEFAULT_ALLELE_RE,
+                    help="regex for allele-style tokens (set to empty string to disable)")
+    args = ap.parse_args()
+
+    if not args.src.exists():
+        print(f"source not found: {args.src}", file=sys.stderr)
+        sys.exit(1)
+    if args.src != args.dst:
+        shutil.copy(args.src, args.dst)
+
+    pron_dict = load_dict(args.dict)
+    print(f"loaded {len(pron_dict)} terms from {args.dict}")
+
+    allele_re = args.allele_regex if args.allele_regex else None
+    prs = Presentation(args.dst)
+    n_injected = 0
+    n_terms_total = 0
+    for slide in prs.slides:
+        if not slide.has_notes_slide:
+            continue
+        body = slide.notes_slide.notes_text_frame.text
+        if args.header in body:
+            continue  # already injected on a previous run
+        terms = find_terms(body, pron_dict, allele_re)
+        if inject_notes(slide, terms, args.header):
+            n_injected += 1
+            n_terms_total += len(terms)
+    prs.save(args.dst)
+    print(f"injected pronunciation on {n_injected} slides ({n_terms_total} term entries)")
+    print(f"OK: {args.dst}")
+
+
+if __name__ == "__main__":
+    main()

package/skills/present-paper/scripts/inject_speaker_notes.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""Inject speaker notes into PowerPoint presentation slides.
+
+This script adds or replaces speaker notes in a PPTX file without modifying
+slide content, layout, or design. Notes are defined as a dictionary mapping
+slide numbers (1-indexed) to note text.
+
+Usage:
+    python inject_speaker_notes.py input.pptx
+    python inject_speaker_notes.py input.pptx -o output.pptx
+    python inject_speaker_notes.py input.pptx --append
+    python inject_speaker_notes.py input.pptx --dry-run
+
+Requirements:
+    pip install python-pptx
+
+License: MIT
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+try:
+    from pptx import Presentation
+except ImportError:
+    print("Error: python-pptx is required. Install with: pip install python-pptx")
+    sys.exit(1)
+
+
+# ---------------------------------------------------------------------------
+# Speaker notes dictionary
+# Map slide number (1-indexed) to note text.
+# Empty string or missing key = skip that slide.
+# ---------------------------------------------------------------------------
+notes: dict[int, str] = {
+    # 1: """Speaker note for slide 1.""",
+    # 2: """Speaker note for slide 2.""",
+}
+
+
+def inject_notes(
+    input_path: str,
+    output_path: str | None = None,
+    append: bool = False,
+    dry_run: bool = False,
+) -> None:
+    """Inject speaker notes into a PPTX file.
+
+    Args:
+        input_path: Path to input PPTX file.
+        output_path: Path to output PPTX file. Defaults to input with _notes suffix.
+        append: If True, append to existing notes instead of replacing.
+        dry_run: If True, print what would be done without saving.
+    """
+    input_file = Path(input_path)
+    if not input_file.exists():
+        print(f"Error: {input_file} not found")
+        sys.exit(1)
+
+    if output_path is None:
+        output_file = input_file.with_stem(input_file.stem + "_notes")
+    else:
+        output_file = Path(output_path)
+
+    prs = Presentation(str(input_file))
+    total_slides = len(prs.slides)
+    updated = 0
+
+    for i, slide in enumerate(prs.slides, 1):
+        if i not in notes or not notes[i]:
+            continue
+
+        if dry_run:
+            preview = notes[i][:80].replace("\n", " ")
+            print(f"  Slide {i:2d}: would {'append' if append else 'set'} → {preview}...")
+            updated += 1
+            continue
+
+        if not slide.has_notes_slide:
+            slide.notes_slide  # creates notes slide
+
+        tf = slide.notes_slide.notes_text_frame
+        if append and tf.text.strip():
+            tf.text = tf.text + "\n\n---\n\n" + notes[i]
+        else:
+            tf.text = notes[i]
+        updated += 1
+
+    if dry_run:
+        print(f"\nDry run: {updated}/{total_slides} slides would be updated")
+        return
+
+    prs.save(str(output_file))
+    print(f"Done: {output_file} ({updated}/{total_slides} slides updated)")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Inject speaker notes into PowerPoint slides",
+        epilog="Notes are defined in the 'notes' dictionary in this script.",
+    )
+    parser.add_argument("input", help="Input PPTX file")
+    parser.add_argument(
+        "-o", "--output",
+        help="Output PPTX file (default: input with _notes suffix)",
+    )
+    parser.add_argument(
+        "--append",
+        action="store_true",
+        help="Append to existing notes instead of replacing",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Print what would be done without saving",
+    )
+    args = parser.parse_args()
+
+    if not notes:
+        print("Warning: notes dictionary is empty. Edit this script to add notes.")
+        print("Example:")
+        print('  notes = {')
+        print('      1: """Your note for slide 1.""",')
+        print('      2: """Your note for slide 2.""",')
+        print('  }')
+        sys.exit(0)
+
+    inject_notes(args.input, args.output, args.append, args.dry_run)
+
+
+if __name__ == "__main__":
+    main()