winter-super-cli 2026.5.26 → 2026.5.27

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

@@ -1,165 +0,0 @@
-#!/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

@@ -1,86 +0,0 @@
-#!/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

@@ -1,149 +0,0 @@
-#!/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

@@ -1,170 +0,0 @@
-#!/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()