winter-super-cli 2026.5.15

package/resources/local/codex/plugins/cache/openai-primary-runtime/documents/26.505.10851/skills/documents/scripts/render_and_diff.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+"""Render two DOCXs and produce visual + structural diffs.
+
+Outputs an easy-to-browse directory:
+  outdir/
+    a_render/  (page-*.png)
+    b_render/  (page-*.png)
+    diff_pages/ (diff-page-*.png for changed pages)
+    summary.json
+    text_a.txt
+    text_b.txt
+    text_diff.txt
+
+Visual diff
+-----------
+We render both DOCXs to PNGs via render_docx.py (LibreOffice headless) and then
+diff each corresponding page using Pillow. We compute differences in RGB (not
+RGBA) because alpha-only differences can cause getbbox() to return None.
+
+Structural diff
+---------------
+We also extract plain text from word/document.xml (w:t runs) and emit a unified
+diff. This catches content regressions even when page rendering shifts.
+
+Usage
+-----
+python scripts/render_and_diff.py a.docx b.docx --outdir /mnt/data/diff
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import zipfile
+from pathlib import Path
+
+from lxml import etree
+from PIL import Image, ImageChops
+
+W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+NS = {"w": W_NS}
+
+
+def _run_render(render_py: str, docx: str, outdir: str) -> None:
+    os.makedirs(outdir, exist_ok=True)
+    cmd = ["python", render_py, docx, "--output_dir", outdir]
+    subprocess.check_call(cmd)
+
+
+def _list_pages(png_dir: str) -> list[Path]:
+    p = Path(png_dir)
+    pages = sorted(p.glob("page-*.png"), key=lambda x: int(x.stem.split("-")[1]))
+    return pages
+
+
+def _diff_images(a_path: Path, b_path: Path, out_path: Path) -> bool:
+    a = Image.open(a_path).convert("RGB")
+    b = Image.open(b_path).convert("RGB")
+    if a.size != b.size:
+        # normalize by padding to max size
+        max_w = max(a.size[0], b.size[0])
+        max_h = max(a.size[1], b.size[1])
+        a2 = Image.new("RGB", (max_w, max_h), (255, 255, 255))
+        b2 = Image.new("RGB", (max_w, max_h), (255, 255, 255))
+        a2.paste(a, (0, 0))
+        b2.paste(b, (0, 0))
+        a, b = a2, b2
+
+    diff = ImageChops.difference(a, b)
+    bbox = diff.getbbox()
+    if bbox is None:
+        return False
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    diff.save(out_path)
+    return True
+
+
+def _extract_text(docx_path: str) -> str:
+    with zipfile.ZipFile(docx_path, "r") as z:
+        xml = z.read("word/document.xml")
+    root = etree.fromstring(xml)
+    paras = []
+    for p in root.xpath(".//w:p", namespaces=NS):
+        texts = [t.text for t in p.xpath(".//w:t", namespaces=NS) if t.text]
+        if texts:
+            paras.append("".join(texts))
+    return "\n".join(paras) + "\n"
+
+
+def _write_text(path: Path, text: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(text, encoding="utf-8")
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("a_docx")
+    ap.add_argument("b_docx")
+    ap.add_argument("--outdir", required=True)
+    ap.add_argument(
+        "--render_py",
+        default=str(Path(__file__).resolve().parents[1] / "render_docx.py"),
+        help="Path to render_docx.py",
+    )
+    args = ap.parse_args()
+
+    outdir = Path(args.outdir)
+    a_render = outdir / "a_render"
+    b_render = outdir / "b_render"
+    diff_dir = outdir / "diff_pages"
+
+    _run_render(args.render_py, args.a_docx, str(a_render))
+    _run_render(args.render_py, args.b_docx, str(b_render))
+
+    a_pages = _list_pages(str(a_render))
+    b_pages = _list_pages(str(b_render))
+
+    max_pages = max(len(a_pages), len(b_pages))
+    changed = []
+
+    for i in range(1, max_pages + 1):
+        a_p = a_render / f"page-{i}.png"
+        b_p = b_render / f"page-{i}.png"
+        if not a_p.exists() or not b_p.exists():
+            changed.append(i)
+            continue
+        out_p = diff_dir / f"diff-page-{i}.png"
+        if _diff_images(a_p, b_p, out_p):
+            changed.append(i)
+
+    # Structural text diff
+    text_a = _extract_text(args.a_docx)
+    text_b = _extract_text(args.b_docx)
+    _write_text(outdir / "text_a.txt", text_a)
+    _write_text(outdir / "text_b.txt", text_b)
+
+    import difflib
+
+    diff_lines = difflib.unified_diff(
+        text_a.splitlines(keepends=True),
+        text_b.splitlines(keepends=True),
+        fromfile="a",
+        tofile="b",
+    )
+    text_diff = "".join(diff_lines)
+    _write_text(outdir / "text_diff.txt", text_diff)
+
+    summary = {
+        "a_docx": os.path.abspath(args.a_docx),
+        "b_docx": os.path.abspath(args.b_docx),
+        "pages_a": len(a_pages),
+        "pages_b": len(b_pages),
+        "changed_pages": changed,
+        "num_changed_pages": len(changed),
+    }
+    (outdir / "summary.json").write_text(json.dumps(summary, indent=2), encoding="utf-8")
+
+    print(f"[OK] wrote {outdir}")
+    print(f"[summary] changed_pages={changed}")
+
+
+if __name__ == "__main__":
+    main()

package/resources/local/codex/plugins/cache/openai-primary-runtime/documents/26.505.10851/skills/documents/scripts/section_audit.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+"""Audit section/page layout settings in a DOCX.
+
+Why this exists
+---------------
+Sections are the #1 source of "why is page 3 landscape" / header/footer bugs.
+Word documents can have multiple sections with independent:
+- orientation (portrait/landscape)
+- page size & margins
+- header/footer linkage (link to previous)
+- different first page / odd-even headers
+
+This script prints a compact per-section report.
+"""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from docx import Document
+
+EMU_PER_INCH = 914400
+
+
+def _inches(x) -> float:
+    # python-docx uses Length objects with .inches, but be defensive.
+    try:
+        return float(x.inches)
+    except Exception:
+        try:
+            return float(x) / EMU_PER_INCH
+        except Exception:
+            return float("nan")
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(
+        description="Audit DOCX sections: orientation, margins, header/footer linkage"
+    )
+    ap.add_argument("docx", type=Path)
+    args = ap.parse_args()
+
+    if not args.docx.exists():
+        raise FileNotFoundError(args.docx)
+
+    doc = Document(str(args.docx))
+
+    print(f"SECTIONS: {len(doc.sections)}")
+    for idx, sec in enumerate(doc.sections, start=1):
+        try:
+            orient = str(sec.orientation).split(".")[-1]
+        except Exception:
+            orient = "(unknown)"
+
+        pw = _inches(sec.page_width)
+        ph = _inches(sec.page_height)
+        lm = _inches(sec.left_margin)
+        rm = _inches(sec.right_margin)
+        tm = _inches(sec.top_margin)
+        bm = _inches(sec.bottom_margin)
+
+        # Header/footer linkage
+        hl = getattr(sec.header, "is_linked_to_previous", None)
+        fl = getattr(sec.footer, "is_linked_to_previous", None)
+
+        dfp = getattr(sec, "different_first_page_header_footer", None)
+        oep = getattr(sec, "odd_and_even_pages_header_footer", None)
+
+        # Start type (new page / continuous) if available
+        st = getattr(sec, "start_type", None)
+        st_s = str(st).split(".")[-1] if st is not None else "(unknown)"
+
+        print(f"\n[Section {idx}] start_type={st_s} orientation={orient}")
+        print(f"  page_size(in): {pw:.2f} x {ph:.2f}")
+        print(f"  margins(in): L={lm:.2f} R={rm:.2f} T={tm:.2f} B={bm:.2f}")
+        print(f"  header_linked_to_previous={hl} footer_linked_to_previous={fl}")
+        print(f"  different_first_page={dfp} odd_even_headers={oep}")
+
+    print("\nREMINDER")
+    print("- If you change orientation mid-document, Word typically creates a new section.")
+    print("- If headers/footers look wrong, check 'Link to Previous' per section.")
+
+
+if __name__ == "__main__":
+    main()

package/resources/local/codex/plugins/cache/openai-primary-runtime/documents/26.505.10851/skills/documents/scripts/set_protection.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+"""Set or clear Word document protection flags (restrict editing).
+
+In OOXML, the setting lives in:
+  word/settings.xml :: <w:documentProtection .../>
+
+We support simple, non-password protection modes:
+  - off
+  - readOnly
+  - comments
+  - trackedChanges
+  - forms
+
+This is high ROI for templating and review workflows.
+
+Usage
+-----
+python scripts/set_protection.py in.docx --mode readOnly --out out.docx
+python scripts/set_protection.py in.docx --mode off --out out.docx
+"""
+
+from __future__ import annotations
+
+import argparse
+import zipfile
+
+from lxml import etree
+
+W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+CT_NS = "http://schemas.openxmlformats.org/package/2006/content-types"
+
+NS = {"w": W_NS, "ct": CT_NS}
+
+SETTINGS_CT = "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml"
+
+
+def _read_xml(z: zipfile.ZipFile, name: str) -> etree._Element:
+    return etree.fromstring(z.read(name))
+
+
+def _xml_bytes(root: etree._Element) -> bytes:
+    return etree.tostring(root, xml_declaration=True, encoding="UTF-8", standalone="yes")
+
+
+def _ensure_settings_part(z: zipfile.ZipFile) -> etree._Element:
+    if "word/settings.xml" in z.namelist():
+        return _read_xml(z, "word/settings.xml")
+    # minimal settings
+    root = etree.Element(f"{{{W_NS}}}settings", nsmap={"w": W_NS})
+    return root
+
+
+def _ensure_settings_override(ct_root: etree._Element) -> bool:
+    # Ensure [Content_Types].xml has Override for settings.xml
+    for ov in ct_root.findall(f"{{{CT_NS}}}Override"):
+        if ov.get("PartName") == "/word/settings.xml":
+            if ov.get("ContentType") != SETTINGS_CT:
+                ov.set("ContentType", SETTINGS_CT)
+                return True
+            return False
+    ov = etree.SubElement(ct_root, f"{{{CT_NS}}}Override")
+    ov.set("PartName", "/word/settings.xml")
+    ov.set("ContentType", SETTINGS_CT)
+    return True
+
+
+def set_protection(settings_root: etree._Element, mode: str) -> bool:
+    changed = False
+    # remove any existing
+    for el in list(settings_root.xpath(".//w:documentProtection", namespaces=NS)):
+        el.getparent().remove(el)
+        changed = True
+
+    if mode == "off":
+        return changed
+
+    # Insert near top (Word doesn't care much)
+    dp = etree.Element(f"{{{W_NS}}}documentProtection")
+    # required-ish flags; enforce=1 is important
+    dp.set(f"{{{W_NS}}}edit", mode)
+    dp.set(f"{{{W_NS}}}enforcement", "1")
+    # don't lock formatting by default
+    dp.set(f"{{{W_NS}}}formatting", "0")
+    # Place as first child for readability
+    settings_root.insert(0, dp)
+    return True
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("in_docx")
+    ap.add_argument(
+        "--mode",
+        required=True,
+        help="Protection mode: off | readOnly | comments | trackedChanges | forms (aliases accepted: read_only, read-only, readonly, tracked_changes, tracked-changes)",
+    )
+    ap.add_argument("--out", required=True)
+    args = ap.parse_args()
+
+    with zipfile.ZipFile(args.in_docx, "r") as zin:
+        settings_root = _ensure_settings_part(zin)
+        ct_root = _read_xml(zin, "[Content_Types].xml")
+
+        # Accept ergonomic aliases (users naturally type read_only, tracked_changes, etc.).
+        mode_in = str(args.mode).strip()
+        norm = mode_in.replace("-", "_")
+        norm = "_".join([p for p in norm.split() if p])
+        key = norm.lower()
+        mode_map = {
+            "off": "off",
+            "readonly": "readOnly",
+            "read_only": "readOnly",
+            "comments": "comments",
+            "trackedchanges": "trackedChanges",
+            "tracked_changes": "trackedChanges",
+            "forms": "forms",
+        }
+        if key not in mode_map:
+            raise SystemExit(
+                f"[set_protection] invalid --mode={mode_in!r}. Use off, readOnly, comments, trackedChanges, forms (aliases: read_only, tracked_changes)."
+            )
+        canonical_mode = mode_map[key]
+
+        changed_settings = set_protection(settings_root, canonical_mode)
+        changed_ct = _ensure_settings_override(ct_root)
+
+        overrides: dict[str, bytes] = {}
+        if changed_settings:
+            overrides["word/settings.xml"] = _xml_bytes(settings_root)
+        if changed_ct:
+            overrides["[Content_Types].xml"] = _xml_bytes(ct_root)
+
+        with zipfile.ZipFile(args.out, "w", zipfile.ZIP_DEFLATED) as zout:
+            existing = {i.filename for i in zin.infolist()}
+            for info in zin.infolist():
+                name = info.filename
+                if name in overrides:
+                    zout.writestr(name, overrides[name])
+                else:
+                    zout.writestr(name, zin.read(name))
+            for name, data in overrides.items():
+                if name not in existing:
+                    zout.writestr(name, data)
+
+    print(f"[OK] wrote {args.out} (mode={canonical_mode})")
+
+
+if __name__ == "__main__":
+    main()

package/resources/local/codex/plugins/cache/openai-primary-runtime/documents/26.505.10851/skills/documents/scripts/style_lint.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+"""Style lint for DOCX (python-docx).
+
+Goal: quickly surface formatting inconsistencies that typically cause
+"why does this paragraph look different" issues:
+
+- direct (run-level) formatting overrides (font, size, bold/italic/color)
+- direct paragraph formatting overrides (space before/after, indents)
+- heading-like paragraphs that are not actually Heading styles
+- font usage summary
+
+This is intentionally conservative: it does not mutate the doc.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+from collections import Counter, defaultdict
+from pathlib import Path
+
+from docx import Document
+
+
+def _iter_paragraphs(doc: Document):
+    # body paragraphs
+    for p in doc.paragraphs:
+        yield p
+    # tables
+    for tbl in doc.tables:
+        for row in tbl.rows:
+            for cell in row.cells:
+                for p in cell.paragraphs:
+                    yield p
+    # headers/footers
+    for section in doc.sections:
+        for p in section.header.paragraphs:
+            yield p
+        for p in section.footer.paragraphs:
+            yield p
+
+
+def _has_direct_run_formatting(run) -> bool:
+    f = run.font
+    return any(
+        v is not None
+        for v in [
+            run.bold,
+            run.italic,
+            run.underline,
+            f.name,
+            f.size,
+            f.color.rgb if f.color else None,
+        ]
+    )
+
+
+def _has_direct_paragraph_formatting(p) -> bool:
+    pf = p.paragraph_format
+    return any(
+        v is not None
+        for v in [
+            pf.left_indent,
+            pf.right_indent,
+            pf.first_line_indent,
+            pf.space_before,
+            pf.space_after,
+            pf.line_spacing,
+        ]
+    )
+
+
+def _looks_like_heading(p) -> bool:
+    # heuristic: short line, bold-ish, ends without period, no list prefix
+    txt = (p.text or "").strip()
+    if not txt:
+        return False
+    if len(txt) > 80:
+        return False
+    if txt.endswith((".", ";", ":")):
+        return False
+    if re.match(r"^\d+(?:\.\d+)*\s+", txt):
+        # numbered headings are common; allow
+        pass
+    # any bold run counts
+    if any(r.bold for r in p.runs if r.text and r.bold):
+        return True
+    # style name might already imply
+    return False
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description="Lint a DOCX for common style/formatting issues")
+    ap.add_argument("input_docx")
+    ap.add_argument(
+        "--json", dest="json_out", default=None, help="Write a JSON report to this path"
+    )
+    args = ap.parse_args()
+
+    doc = Document(args.input_docx)
+
+    font_names = Counter()
+    direct_runs = 0
+    direct_paras = 0
+    heading_like_not_heading = []
+
+    # collect examples (limit)
+    examples = defaultdict(list)
+
+    for i, p in enumerate(_iter_paragraphs(doc), start=1):
+        style_name = p.style.name if p.style is not None else ""
+
+        if _has_direct_paragraph_formatting(p):
+            direct_paras += 1
+            if len(examples["direct_paragraph_formatting"]) < 5:
+                examples["direct_paragraph_formatting"].append(
+                    {"para_index": i, "text": p.text[:120], "style": style_name}
+                )
+
+        if _looks_like_heading(p) and not style_name.startswith("Heading"):
+            heading_like_not_heading.append(
+                {"para_index": i, "text": p.text[:120], "style": style_name}
+            )
+
+        for r in p.runs:
+            if r.text:
+                if r.font and r.font.name:
+                    font_names[r.font.name] += len(r.text)
+                if _has_direct_run_formatting(r):
+                    direct_runs += 1
+                    if len(examples["direct_run_formatting"]) < 5:
+                        examples["direct_run_formatting"].append(
+                            {
+                                "para_index": i,
+                                "run_text": r.text[:80],
+                                "style": style_name,
+                            }
+                        )
+
+    report = {
+        "input": str(Path(args.input_docx).resolve()),
+        "fonts_by_char_count": dict(font_names.most_common()),
+        "direct_run_formatting_runs": direct_runs,
+        "direct_paragraph_formatting_paragraphs": direct_paras,
+        "heading_like_paragraphs_not_heading_style": heading_like_not_heading[:20],
+        "examples": dict(examples),
+        "notes": [
+            "Direct formatting is not always wrong, but it often causes inconsistent output when templates change.",
+            "Heading-like paragraphs not using Heading styles can break TOC and accessibility.",
+        ],
+    }
+
+    if args.json_out:
+        Path(args.json_out).write_text(json.dumps(report, indent=2), encoding="utf-8")
+
+    # human-friendly summary
+    print("[style_lint] direct run-formatting runs:", direct_runs)
+    print("[style_lint] direct paragraph-formatting paragraphs:", direct_paras)
+    if font_names:
+        top = ", ".join([f"{k}({v})" for k, v in font_names.most_common(5)])
+        print("[style_lint] top fonts by char count:", top)
+    if heading_like_not_heading:
+        print("[style_lint] heading-like paragraphs not using Heading styles (first 10):")
+        for item in heading_like_not_heading[:10]:
+            print(f"  - #{item['para_index']}: style='{item['style']}' text='{item['text']}'")
+
+
+if __name__ == "__main__":
+    main()