winter-super-cli 2026.5.15

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

@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+"""Flatten REF/PAGEREF fields to literal text runs.
+
+LibreOffice headless rendering can sometimes omit REF field results even when
+Word displays them correctly. For screenshot-based regression testing, it can
+be helpful to replace the field construct with its current cached visible text.
+
+This script finds field sequences of the form:
+  <w:fldChar w:fldCharType="begin"/>
+  ... <w:instrText>REF ...
+  <w:fldChar w:fldCharType="separate"/>
+  ... <w:t>VISIBLE RESULT</w:t>
+  <w:fldChar w:fldCharType="end"/>
+and replaces the entire block with a single run containing "VISIBLE RESULT".
+
+Scope: best-effort on paragraph-contained fields.
+
+Usage
+-----
+python scripts/flatten_ref_fields.py in.docx --out out.docx
+"""
+
+from __future__ import annotations
+
+import argparse
+import re
+import zipfile
+
+from lxml import etree
+
+W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+NS = {"w": W_NS}
+
+
+def w(tag: str) -> str:
+    return f"{{{W_NS}}}{tag}"
+
+
+def _xml_bytes(root: etree._Element) -> bytes:
+    return etree.tostring(root, xml_declaration=True, encoding="UTF-8", standalone="yes")
+
+
+def _is_begin(el: etree._Element) -> bool:
+    return el.tag == w("fldChar") and el.get(w("fldCharType")) == "begin"
+
+
+def _is_separate(el: etree._Element) -> bool:
+    return el.tag == w("fldChar") and el.get(w("fldCharType")) == "separate"
+
+
+def _is_end(el: etree._Element) -> bool:
+    return el.tag == w("fldChar") and el.get(w("fldCharType")) == "end"
+
+
+def _instr_text(p: etree._Element, start_idx: int, end_idx: int) -> str:
+    txt = []
+    for r in p[start_idx:end_idx]:
+        for it in r.xpath(".//w:instrText/text()", namespaces=NS):
+            txt.append(it)
+    return "".join(txt)
+
+
+def _visible_text(p: etree._Element, start_idx: int, end_idx: int) -> str:
+    txt = []
+    for r in p[start_idx:end_idx]:
+        for t in r.xpath(".//w:t/text()", namespaces=NS):
+            txt.append(t)
+    return "".join(txt)
+
+
+def flatten_part(root: etree._Element) -> int:
+    changed = 0
+    for p in root.xpath(".//w:p", namespaces=NS):
+        kids = list(p)
+        i = 0
+        while i < len(kids):
+            # Look for run containing fldChar begin.
+            r = kids[i]
+            fld = r.find(".//w:fldChar", namespaces=NS)
+            if fld is None or not _is_begin(fld):
+                i += 1
+                continue
+
+            # Find the end run containing fldChar end.
+            j = i + 1
+            separate_idx = None
+            end_idx = None
+            while j < len(kids):
+                fldj = kids[j].find(".//w:fldChar", namespaces=NS)
+                if fldj is not None and _is_separate(fldj):
+                    separate_idx = j
+                if fldj is not None and _is_end(fldj):
+                    end_idx = j
+                    break
+                j += 1
+            if end_idx is None or separate_idx is None:
+                i += 1
+                continue
+
+            instr = _instr_text(p, i, separate_idx + 1)
+            if not re.search(r"\b(PAGE)?REF\b", instr, flags=re.IGNORECASE):
+                i += 1
+                continue
+
+            visible = _visible_text(p, separate_idx + 1, end_idx)
+            if not visible.strip():
+                i = end_idx + 1
+                continue
+
+            # Replace i..end_idx with a single run of visible text.
+            new_r = etree.Element(w("r"))
+            t = etree.SubElement(new_r, w("t"))
+            t.text = visible
+
+            # Insert before i, then remove old nodes.
+            p.insert(i, new_r)
+            for k in range(i + 1, end_idx + 2):
+                try:
+                    p.remove(kids[k])
+                except Exception:
+                    pass
+
+            changed += 1
+            kids = list(p)
+            i += 1
+
+    return changed
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description="Flatten REF/PAGEREF fields to literal text")
+    ap.add_argument("in_docx")
+    ap.add_argument("--out", required=True)
+    args = ap.parse_args()
+
+    with zipfile.ZipFile(args.in_docx, "r") as zin:
+        overrides: dict[str, bytes] = {}
+        root = etree.fromstring(zin.read("word/document.xml"))
+        n = flatten_part(root)
+        if n:
+            overrides["word/document.xml"] = _xml_bytes(root)
+        with zipfile.ZipFile(args.out, "w", zipfile.ZIP_DEFLATED) as zout:
+            for info in zin.infolist():
+                name = info.filename
+                if name in overrides:
+                    zout.writestr(name, overrides[name])
+                else:
+                    zout.writestr(name, zin.read(name))
+
+    print(f"[OK] wrote {args.out} (fields_flattened={n})")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+"""Report footnotes/endnotes usage in a DOCX.
+
+True footnotes/endnotes are NOT "text in footer". They live in separate OOXML
+parts:
+  - word/footnotes.xml
+  - word/endnotes.xml
+
+and are referenced from the body via:
+  - w:footnoteReference w:id="..."
+  - w:endnoteReference w:id="..."
+
+This reporter scans for:
+  - presence of footnotes.xml/endnotes.xml
+  - counts of referenced IDs and defined IDs
+  - first few snippets of note text
+
+Usage
+-----
+python scripts/footnotes_report.py in.docx
+"""
+
+from __future__ import annotations
+
+import zipfile
+from collections import Counter
+
+from lxml import etree
+
+W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+NS = {"w": W_NS}
+
+
+def _read(z: zipfile.ZipFile, name: str) -> etree._Element:
+    return etree.fromstring(z.read(name))
+
+
+def _note_text(note_el: etree._Element) -> str:
+    texts = [t.text for t in note_el.xpath(".//w:t", namespaces=NS) if t.text]
+    s = "".join(texts).strip()
+    return s
+
+
+def _report_part(z: zipfile.ZipFile, part: str, kind: str) -> None:
+    root = _read(z, part)
+    # Footnotes/endnotes define separators with id -1,0; real notes are >=1
+    notes = root.xpath(f".//w:{kind}[number(@w:id) >= 1]", namespaces=NS)
+    ids = [int(n.get(f"{{{W_NS}}}id")) for n in notes]
+    print(
+        f"[{part}] defined_{kind}s={len(ids)} ids={sorted(ids)[:10]}{'...' if len(ids) > 10 else ''}"
+    )
+    for n in notes[:5]:
+        nid = n.get(f"{{{W_NS}}}id")
+        txt = _note_text(n)
+        if txt:
+            print(f"  - id={nid}: {txt[:120]}")
+
+
+def main() -> None:
+    import argparse
+
+    ap = argparse.ArgumentParser()
+    ap.add_argument("docx")
+    args = ap.parse_args()
+
+    with zipfile.ZipFile(args.docx, "r") as z:
+        doc = _read(z, "word/document.xml")
+
+        fn_refs = [
+            int(x.get(f"{{{W_NS}}}id")) for x in doc.xpath(".//w:footnoteReference", namespaces=NS)
+        ]
+        en_refs = [
+            int(x.get(f"{{{W_NS}}}id")) for x in doc.xpath(".//w:endnoteReference", namespaces=NS)
+        ]
+
+        print(f"[document.xml] footnoteReferences={len(fn_refs)} ids={sorted(set(fn_refs))}")
+        print(f"[document.xml] endnoteReferences={len(en_refs)} ids={sorted(set(en_refs))}")
+
+        if fn_refs:
+            c = Counter(fn_refs)
+            dupes = [k for k, v in c.items() if v > 1]
+            if dupes:
+                print(
+                    f"[warn] duplicated footnote reference ids (multiple references to same note): {dupes}"
+                )
+
+        if "word/footnotes.xml" in z.namelist():
+            _report_part(z, "word/footnotes.xml", "footnote")
+        else:
+            print("[word/footnotes.xml] MISSING")
+
+        if "word/endnotes.xml" in z.namelist():
+            _report_part(z, "word/endnotes.xml", "endnote")
+        else:
+            print("[word/endnotes.xml] MISSING")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""Audit heading hierarchy and numbering in a DOCX.
+
+Checks (best-effort)
+-------------------
+- Which heading styles appear (Heading 1/2/3/...)
+- Whether heading levels jump (e.g., Heading 3 immediately after Heading 1)
+- Whether paragraphs use numbering without a heading style (common source of broken TOC)
+
+This is not a full style-linter. It is meant as a fast QA signal before you render.
+"""
+
+from __future__ import annotations
+
+import argparse
+from collections import Counter
+from pathlib import Path
+
+from docx import Document
+
+
+def _heading_level(style_name: str | None) -> int | None:
+    if not style_name:
+        return None
+    s = style_name.strip().lower()
+    if not s.startswith("heading"):
+        return None
+    parts = s.split()
+    if len(parts) < 2:
+        return None
+    try:
+        return int(parts[1])
+    except Exception:
+        return None
+
+
+def _has_numbering(p) -> bool:
+    # python-docx doesn't expose numbering cleanly; check OOXML
+    pPr = p._p.pPr
+    if pPr is None:
+        return False
+    return pPr.numPr is not None
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description="Audit heading hierarchy + numbering usage in a DOCX")
+    ap.add_argument("docx", type=Path)
+    ap.add_argument("--max_findings", type=int, default=20)
+    args = ap.parse_args()
+
+    if not args.docx.exists():
+        raise FileNotFoundError(args.docx)
+
+    doc = Document(str(args.docx))
+    h_counts: Counter[int] = Counter()
+    jumps: list[str] = []
+    numbered_non_heading: list[str] = []
+
+    last_h: int | None = None
+
+    for i, p in enumerate(doc.paragraphs, start=1):
+        style = getattr(p.style, "name", None)
+        lvl = _heading_level(style)
+        if lvl is not None:
+            h_counts[lvl] += 1
+            if last_h is not None and lvl > last_h + 1:
+                jumps.append(f"p#{i}: Heading {last_h} → Heading {lvl}: {p.text[:80]!r}")
+            last_h = lvl
+        if _has_numbering(p) and lvl is None:
+            # numbered list without Heading style - often intended to be numbered headings
+            txt = (p.text or "").strip()
+            if txt:
+                numbered_non_heading.append(f"p#{i}: style={style!r} text={txt[:80]!r}")
+
+    print("HEADING STYLE COUNTS")
+    if not h_counts:
+        print("- (no Heading styles found)")
+    else:
+        for lvl in sorted(h_counts):
+            print(f"- Heading {lvl}: {h_counts[lvl]}")
+
+    if jumps:
+        print("\nPOTENTIAL HEADING LEVEL JUMPS (review)")
+        for s in jumps[: args.max_findings]:
+            print(f"- {s}")
+        if len(jumps) > args.max_findings:
+            print(f"- ... ({len(jumps) - args.max_findings} more)")
+
+    if numbered_non_heading:
+        print("\nNUMBERING WITHOUT HEADING STYLE (common TOC issue)")
+        for s in numbered_non_heading[: args.max_findings]:
+            print(f"- {s}")
+        if len(numbered_non_heading) > args.max_findings:
+            print(f"- ... ({len(numbered_non_heading) - args.max_findings} more)")
+
+    print("\nREMINDER")
+    print(
+        "- TOC relies on Heading styles (Heading 1/2/3...). Avoid manual numbering + direct formatting for headings."
+    )
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,171 @@
+#!/usr/bin/env python3
+"""Audit images in a DOCX (inline vs floating, size, relationship targets).
+
+Why this exists
+---------------
+Image placement is the #1 Word-vs-LibreOffice mismatch. A fast audit helps
+answer "do we have floating/anchored figures" and "what size are the images".
+
+This script:
+- Scans document.xml + headers + footers for drawings
+- Detects inline (wp:inline) vs floating (wp:anchor)
+- Extracts the embed relationship id (r:embed) and resolves it to the image file
+- Prints sizes (in inches) from the OOXML extents
+
+Notes
+-----
+- python-docx mostly creates inline images; floating/anchored images usually come from Word UI.
+- This script is best-effort; some drawings (charts, SmartArt) use different parts.
+"""
+
+from __future__ import annotations
+
+import argparse
+import zipfile
+from collections import Counter
+from pathlib import Path
+
+from lxml import etree
+
+W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+R_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+WP_NS = "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing"
+A_NS = "http://schemas.openxmlformats.org/drawingml/2006/main"
+
+REL_NS = "http://schemas.openxmlformats.org/package/2006/relationships"
+
+NS = {
+    "w": W_NS,
+    "r": R_NS,
+    "wp": WP_NS,
+    "a": A_NS,
+    "rel": REL_NS,
+}
+
+EMU_PER_INCH = 914400
+
+
+def _iter_content_parts(z: zipfile.ZipFile):
+    for name in z.namelist():
+        if not name.startswith("word/"):
+            continue
+        if name.endswith("document.xml"):
+            yield name
+        base = name.rsplit("/", 1)[-1]
+        if base.startswith("header") and base.endswith(".xml"):
+            yield name
+        if base.startswith("footer") and base.endswith(".xml"):
+            yield name
+
+
+def _rels_path_for_part(part_name: str) -> str:
+    # e.g. word/document.xml -> word/_rels/document.xml.rels
+    base = part_name.rsplit("/", 1)[-1]
+    return f"word/_rels/{base}.rels"
+
+
+def _load_rels_map(z: zipfile.ZipFile, part_name: str) -> dict[str, str]:
+    rels_name = _rels_path_for_part(part_name)
+    if rels_name not in z.namelist():
+        return {}
+    root = etree.fromstring(z.read(rels_name))
+    out: dict[str, str] = {}
+    for rel in root.findall("rel:Relationship", namespaces=NS):
+        rid = rel.get("Id")
+        tgt = rel.get("Target")
+        if rid and tgt:
+            out[rid] = tgt
+    return out
+
+
+def _inches_from_emu(v: str | None) -> float | None:
+    if not v:
+        return None
+    try:
+        return float(int(v)) / EMU_PER_INCH
+    except Exception:
+        return None
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description="Audit images in a DOCX (inline vs floating, sizes)")
+    ap.add_argument("docx", type=Path)
+    ap.add_argument("--max_rows", type=int, default=50)
+    args = ap.parse_args()
+
+    if not args.docx.exists():
+        raise FileNotFoundError(args.docx)
+
+    rows = []
+    kind_counts: Counter[str] = Counter()
+
+    with zipfile.ZipFile(args.docx, "r") as z:
+        for part in _iter_content_parts(z):
+            rels = _load_rels_map(z, part)
+            parser = etree.XMLParser(recover=True)
+            root = etree.fromstring(z.read(part), parser=parser)
+
+            # Find both inline and anchor drawings
+            for kind, xpath in (
+                ("inline", ".//wp:inline"),
+                ("anchor", ".//wp:anchor"),
+            ):
+                for el in root.findall(xpath, namespaces=NS):
+                    kind_counts[kind] += 1
+
+                    # Size extents: wp:extent cx/cy
+                    ext = el.find("wp:extent", namespaces=NS)
+                    w_in = _inches_from_emu(ext.get("cx") if ext is not None else None)
+                    h_in = _inches_from_emu(ext.get("cy") if ext is not None else None)
+
+                    # Relationship id: a:blip r:embed
+                    blip = el.find(".//a:blip", namespaces=NS)
+                    rid = blip.get(f"{{{R_NS}}}embed") if blip is not None else None
+                    tgt = rels.get(rid, "") if rid else ""
+
+                    img_zip_path = ""
+                    img_bytes = None
+                    if tgt and tgt.startswith("media/"):
+                        img_zip_path = "word/" + tgt
+                        if img_zip_path in z.namelist():
+                            try:
+                                img_bytes = z.read(img_zip_path)
+                            except Exception:
+                                img_bytes = None
+
+                    rows.append(
+                        {
+                            "part": part,
+                            "kind": kind,
+                            "rId": rid or "",
+                            "target": tgt,
+                            "zip_path": img_zip_path,
+                            "size_in": f"{w_in:.2f} x {h_in:.2f}" if w_in and h_in else "(unknown)",
+                            "bytes": str(len(img_bytes)) if img_bytes is not None else "",
+                        }
+                    )
+
+    if not rows:
+        print("No inline/anchored drawings found in document/header/footer parts.")
+        return
+
+    print("IMAGE KINDS")
+    for k, n in kind_counts.most_common():
+        print(f"- {k}: {n}")
+
+    print("\nROWS (part | kind | size | target)")
+    for r in rows[: args.max_rows]:
+        print(f"- {r['part']} | {r['kind']} | {r['size_in']} | {r['target']}")
+    if len(rows) > args.max_rows:
+        print(f"- ... ({len(rows) - args.max_rows} more)")
+
+    if kind_counts.get("anchor"):
+        print("\nWARNING")
+        print(
+            "- Floating/anchored images detected (wp:anchor). These are the most common Word-vs-LO mismatch."
+        )
+        print("  Strongly recommend: render to PNG and check placement on every affected page.")
+
+
+if __name__ == "__main__":
+    main()