winter-super-cli 2026.5.15

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

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+"""Export a DOCX table to CSV.
+
+Why this exists
+---------------
+Round-tripping tables between spreadsheets and DOCX is common in reporting workflows.
+This exporter is intentionally simple: it extracts plain cell text.
+
+Usage examples
+--------------
+python scripts/docx_table_to_csv.py input.docx --table_index 0 --out table0.csv
+
+Notes
+-----
+- Merged cells are exported as their visible text in each grid cell (Word stores these differently).
+- Multi-paragraph cells are joined with newlines.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import os
+import sys
+from pathlib import Path
+
+from docx import Document
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description="Export a DOCX table to CSV")
+    ap.add_argument("docx", type=Path)
+    ap.add_argument("--table_index", type=int, default=0)
+    ap.add_argument("--out", type=Path, required=True)
+    args = ap.parse_args()
+
+    if not args.docx.exists():
+        raise FileNotFoundError(args.docx)
+
+    doc = Document(str(args.docx))
+    if not doc.tables:
+        raise RuntimeError("No tables found in DOCX")
+    if args.table_index < 0 or args.table_index >= len(doc.tables):
+        raise RuntimeError(f"table_index out of range (0..{len(doc.tables) - 1})")
+
+    t = doc.tables[args.table_index]
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+
+    with args.out.open("w", newline="", encoding="utf-8") as f:
+        w = csv.writer(f)
+        for row in t.rows:
+            out_row = []
+            for cell in row.cells:
+                parts = []
+                for p in cell.paragraphs:
+                    txt = (p.text or "").strip("\n")
+                    if txt:
+                        parts.append(txt)
+                out_row.append("\n".join(parts))
+            w.writerow(out_row)
+
+    print(f"[OK] Exported table {args.table_index} → {args.out}")
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        if os.environ.get("DOCS_DEBUG") == "1":
+            raise
+        print(f"[ERROR] {e}", file=sys.stderr)
+        raise SystemExit(2)

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

@@ -0,0 +1,310 @@
+#!/usr/bin/env python3
+"""Materialize (freeze) common Word fields into plain text.
+
+Why
+---
+Word fields (SEQ, REF, PAGE, etc.) are normally evaluated by Word. In automation
+pipelines (and headless renderers), fields sometimes don't update, which makes
+visual QA confusing.
+
+This script "materializes" a subset of fields by writing their *display*
+(result) text directly into the DOCX, while keeping the field code structure.
+That way:
+- PNG rendering shows stable numbers/text
+- The DOCX still contains the original field instructions for Word to update
+
+Supported
+---------
+- SEQ <Type>   : e.g., "SEQ Figure" or "SEQ Table" (sequential order in-document)
+- REF <Bookmark>: writes the current text inside the bookmark
+
+Not supported (by design)
+--------------------------
+- PAGE / NUMPAGES: requires pagination/layout
+- TOC: should be rebuilt via Word or a dedicated TOC generator
+
+Usage
+-----
+python scripts/fields_materialize.py in.docx --out out.docx
+python scripts/fields_materialize.py in.docx --out out.docx --only SEQ
+python scripts/fields_materialize.py in.docx --out out.docx --only SEQ REF
+"""
+
+from __future__ import annotations
+
+import argparse
+import glob
+import os
+import re
+import tempfile
+from pathlib import Path
+
+from lxml import etree
+
+try:
+    from docx_ooxml_patch import unzip_docx, zip_docx
+except Exception:
+    import shutil
+    import zipfile
+
+    def unzip_docx(docx_path: Path, out_dir: Path) -> None:
+        if out_dir.exists():
+            shutil.rmtree(out_dir)
+        out_dir.mkdir(parents=True, exist_ok=True)
+        with zipfile.ZipFile(docx_path, "r") as z:
+            z.extractall(out_dir)
+
+    def zip_docx(in_dir: Path, out_docx_path: Path) -> None:
+        if out_docx_path.exists():
+            out_docx_path.unlink()
+        with zipfile.ZipFile(out_docx_path, "w", compression=zipfile.ZIP_DEFLATED) as z:
+            for root, _dirs, files in os.walk(in_dir):
+                for f in files:
+                    abs_path = Path(root) / f
+                    rel_path = abs_path.relative_to(in_dir)
+                    z.write(abs_path, rel_path.as_posix())
+
+
+W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+NS = {
+    "w": W_NS,
+    "r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+}
+XML_NS = "http://www.w3.org/XML/1998/namespace"
+
+
+def qn(local: str) -> str:
+    return f"{{{W_NS}}}{local}"
+
+
+def qna(local: str) -> str:
+    # attribute in w: namespace
+    return f"{{{W_NS}}}{local}"
+
+
+def _set_text_preserve(t_el: etree._Element, value: str) -> None:
+    t_el.text = value
+    if value.startswith(" ") or value.endswith(" "):
+        t_el.set(f"{{{XML_NS}}}space", "preserve")
+
+
+def _list_parts(unzipped: Path) -> list[Path]:
+    word = unzipped / "word"
+    parts = [word / "document.xml"]
+    parts += [Path(p) for p in sorted(glob.glob(str(word / "header*.xml")))]
+    parts += [Path(p) for p in sorted(glob.glob(str(word / "footer*.xml")))]
+    return [p for p in parts if p.exists()]
+
+
+def build_bookmark_text(root: etree._Element) -> dict[str, str]:
+    """Map bookmark name -> text inside the bookmark range (best-effort)."""
+
+    # Stack of open bookmarks: list of [id, name, buf]
+    open_stack: list[tuple[str, str, list[str]]] = []
+    out: dict[str, str] = {}
+
+    for el in root.iter():
+        if el.tag == qn("bookmarkStart"):
+            bid = el.get(qna("id")) or ""
+            name = el.get(qna("name")) or ""
+            # Skip Word internal bookmarks like _GoBack
+            if name:
+                open_stack.append((bid, name, []))
+        elif el.tag == qn("bookmarkEnd"):
+            bid = el.get(qna("id")) or ""
+            # Pop the most recent matching id
+            idx = None
+            for i in range(len(open_stack) - 1, -1, -1):
+                if open_stack[i][0] == bid:
+                    idx = i
+                    break
+            if idx is not None:
+                _bid, name, buf = open_stack.pop(idx)
+                # If nested, remaining open bookmarks should also include text, but we keep it simple.
+                out[name] = "".join(buf)
+        elif el.tag == qn("t"):
+            if not open_stack:
+                continue
+            txt = el.text or ""
+            # Append to all open bookmarks (handles nesting; depth is usually tiny)
+            for i in range(len(open_stack)):
+                open_stack[i][2].append(txt)
+
+    return out
+
+
+def _materialize_seq_in_root(root: etree._Element) -> int:
+    """Materialize SEQ fields in-place and return number of fields updated."""
+
+    seq_counters: dict[str, int] = {}
+    updated = 0
+
+    for p in root.findall(".//w:p", namespaces=NS):
+        runs = p.xpath(".//w:r", namespaces=NS)
+
+        in_field = False
+        seen_separate = False
+        instr = ""
+        result_text_nodes: list[etree._Element] = []
+
+        for r in runs:
+            fld = r.find("w:fldChar", namespaces=NS)
+            if fld is not None:
+                ftype = fld.get(qna("fldCharType"))
+                if ftype == "begin":
+                    in_field = True
+                    seen_separate = False
+                    instr = ""
+                    result_text_nodes = []
+                    continue
+                if in_field and ftype == "separate":
+                    seen_separate = True
+                    continue
+                if in_field and ftype == "end":
+                    instr_norm = " ".join(instr.split())
+                    m_seq = re.search(r"\bSEQ\s+([A-Za-z0-9_]+)", instr_norm)
+                    if m_seq:
+                        seq_name = m_seq.group(1)
+                        seq_counters[seq_name] = seq_counters.get(seq_name, 0) + 1
+                        value = str(seq_counters[seq_name])
+                        if result_text_nodes:
+                            _set_text_preserve(result_text_nodes[0], value)
+                            for extra in result_text_nodes[1:]:
+                                _set_text_preserve(extra, "")
+                            updated += 1
+
+                    in_field = False
+                    seen_separate = False
+                    instr = ""
+                    result_text_nodes = []
+                    continue
+
+            if not in_field:
+                continue
+
+            instr_el = r.find("w:instrText", namespaces=NS)
+            if instr_el is not None and not seen_separate:
+                instr += instr_el.text or ""
+
+            if seen_separate:
+                for t in r.findall(".//w:t", namespaces=NS):
+                    result_text_nodes.append(t)
+
+    return updated
+
+
+def _materialize_ref_in_root(root: etree._Element) -> int:
+    """Materialize REF fields in-place (based on current bookmark text)."""
+
+    bm_text = build_bookmark_text(root)
+    updated = 0
+
+    for p in root.findall(".//w:p", namespaces=NS):
+        runs = p.xpath(".//w:r", namespaces=NS)
+
+        in_field = False
+        seen_separate = False
+        instr = ""
+        result_text_nodes: list[etree._Element] = []
+
+        for r in runs:
+            fld = r.find("w:fldChar", namespaces=NS)
+            if fld is not None:
+                ftype = fld.get(qna("fldCharType"))
+                if ftype == "begin":
+                    in_field = True
+                    seen_separate = False
+                    instr = ""
+                    result_text_nodes = []
+                    continue
+                if in_field and ftype == "separate":
+                    seen_separate = True
+                    continue
+                if in_field and ftype == "end":
+                    instr_norm = " ".join(instr.split())
+                    m_ref = re.search(r"\bREF\s+([A-Za-z0-9_:\-\.]+)", instr_norm)
+                    if m_ref:
+                        bname = m_ref.group(1)
+                        value = bm_text.get(bname)
+                        if value is not None and result_text_nodes:
+                            _set_text_preserve(result_text_nodes[0], value)
+                            for extra in result_text_nodes[1:]:
+                                _set_text_preserve(extra, "")
+                            updated += 1
+
+                    in_field = False
+                    seen_separate = False
+                    instr = ""
+                    result_text_nodes = []
+                    continue
+
+            if not in_field:
+                continue
+
+            instr_el = r.find("w:instrText", namespaces=NS)
+            if instr_el is not None and not seen_separate:
+                instr += instr_el.text or ""
+
+            if seen_separate:
+                for t in r.findall(".//w:t", namespaces=NS):
+                    result_text_nodes.append(t)
+
+    return updated
+
+
+def materialize_fields_in_root(root: etree._Element, only: set[str]) -> int:
+    """Materialize SEQ/REF fields in a single XML root.
+
+    Important: REF results depend on the *current* text inside the bookmarked
+    range. If a bookmark wraps a SEQ field result, we must materialize SEQ first
+    so REF doesn't capture the placeholder "0".
+
+    Returns number of fields updated.
+    """
+
+    total = 0
+    if "SEQ" in only:
+        total += _materialize_seq_in_root(root)
+    if "REF" in only:
+        total += _materialize_ref_in_root(root)
+    return total
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description="Materialize SEQ/REF field results inside a DOCX")
+    ap.add_argument("input_docx")
+    ap.add_argument("--out", required=True, help="Output DOCX path")
+    ap.add_argument(
+        "--only",
+        nargs="+",
+        default=["SEQ", "REF"],
+        choices=["SEQ", "REF"],
+        help="Which field types to materialize (default: SEQ REF)",
+    )
+    args = ap.parse_args()
+
+    input_docx = Path(args.input_docx)
+    out_docx = Path(args.out)
+    only = set(args.only)
+
+    with tempfile.TemporaryDirectory(prefix="docx_unzip_") as td:
+        unzipped = Path(td) / "docx"
+        unzip_docx(input_docx, unzipped)
+
+        parser = etree.XMLParser(remove_blank_text=False)
+        total = 0
+        for part in _list_parts(unzipped):
+            tree = etree.parse(str(part), parser)
+            root = tree.getroot()
+            n = materialize_fields_in_root(root, only=only)
+            if n:
+                tree.write(str(part), xml_declaration=True, encoding="UTF-8", standalone="yes")
+            total += n
+
+        zip_docx(unzipped, out_docx)
+
+    print(f"[OK] materialized {total} field(s) -> {out_docx}")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+"""Report Word fields present in a DOCX.
+
+Why this exists
+--------------
+Many "looks wrong" render issues are simply *stale fields* (PAGE/NUMPAGES/TOC/REF, etc.).
+LibreOffice headless vs Word GUI can update fields differently, and some PDF exports can show
+placeholders if fields weren't refreshed.
+
+This script scans OOXML parts for fields and prints:
+- Per-part list of field instructions (best-effort)
+- Counts by field type (first token of instruction)
+- A quick "stale field" hint (e.g., TOC present → remind to update fields)
+
+It is intentionally simple: it does not try to fully interpret field switches.
+"""
+
+from __future__ import annotations
+
+import argparse
+import re
+import zipfile
+from collections import Counter, defaultdict
+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"
+
+NS = {"w": W_NS, "r": R_NS}
+
+
+def _field_type(instr: str) -> str:
+    s = (instr or "").strip()
+    if not s:
+        return "(empty)"
+    return s.split()[0].upper()
+
+
+def _iter_word_xml_parts(z: zipfile.ZipFile):
+    # Document + headers/footers are the common places fields live.
+    for name in z.namelist():
+        if not name.startswith("word/"):
+            continue
+        if not name.endswith(".xml"):
+            continue
+        base = name.rsplit("/", 1)[-1]
+        if base in {"document.xml", "settings.xml"}:
+            yield name
+        elif base.startswith(("header", "footer")):
+            yield name
+        elif base in {"footnotes.xml", "endnotes.xml"}:
+            yield name
+
+
+def extract_field_instructions(xml_bytes: bytes) -> list[str]:
+    """Extract field instructions from a WordprocessingML part.
+
+    Handles:
+    - Simple fields: <w:fldSimple w:instr="..."/>
+    - Complex fields: <w:instrText> tokens between fldChar begin/end
+
+    For complex fields, we concatenate instrText nodes in document order.
+    """
+
+    parser = etree.XMLParser(recover=True, remove_blank_text=False)
+    root = etree.fromstring(xml_bytes, parser=parser)
+
+    out: list[str] = []
+
+    # 1) fldSimple
+    for el in root.findall(".//w:fldSimple", namespaces=NS):
+        instr = el.get(f"{{{W_NS}}}instr") or el.get("w:instr")  # defensive
+        if instr:
+            out.append(instr)
+
+    # 2) Complex fields
+    # Approach: walk runs in order, track state when we see fldChar begin → gather instrText
+    in_field = False
+    buf: list[str] = []
+    for node in root.iter():
+        # fldChar
+        if node.tag == f"{{{W_NS}}}fldChar":
+            t = node.get(f"{{{W_NS}}}fldCharType")
+            if t == "begin":
+                in_field = True
+                buf = []
+            elif t == "end" and in_field:
+                instr = "".join(buf).strip()
+                if instr:
+                    out.append(instr)
+                in_field = False
+                buf = []
+            continue
+
+        # instrText (can be split across runs)
+        if in_field and node.tag == f"{{{W_NS}}}instrText":
+            buf.append(node.text or "")
+
+    # As a fallback, if a doc has instrText but malformed fldChar structure,
+    # we still surface them so users can see something.
+    if not out:
+        texts = [
+            (t.text or "")
+            for t in root.findall(".//w:instrText", namespaces=NS)
+            if (t.text or "").strip()
+        ]
+        out.extend(texts)
+
+    # Normalize whitespace to make output readable
+    normed: list[str] = []
+    for s in out:
+        s2 = re.sub(r"\s+", " ", s).strip()
+        if s2:
+            normed.append(s2)
+    return normed
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description="Scan a DOCX for Word fields (PAGE/TOC/REF/...).")
+    ap.add_argument("docx", type=Path)
+    ap.add_argument("--max_examples", type=int, default=8, help="Examples to print per field type")
+    args = ap.parse_args()
+
+    docx = args.docx
+    if not docx.exists():
+        raise FileNotFoundError(docx)
+
+    by_part: dict[str, list[str]] = {}
+    type_counts: Counter[str] = Counter()
+    examples: dict[str, list[str]] = defaultdict(list)
+
+    with zipfile.ZipFile(docx, "r") as z:
+        for part in _iter_word_xml_parts(z):
+            try:
+                instrs = extract_field_instructions(z.read(part))
+            except Exception:
+                continue
+            if not instrs:
+                continue
+            by_part[part] = instrs
+            for instr in instrs:
+                ft = _field_type(instr)
+                type_counts[ft] += 1
+                if len(examples[ft]) < args.max_examples:
+                    examples[ft].append(instr)
+
+    if not by_part:
+        print("No fields found in document.xml/headers/footers.")
+        return
+
+    print("FIELD COUNTS")
+    for ft, n in type_counts.most_common():
+        print(f"- {ft}: {n}")
+
+    print("\nEXAMPLES")
+    for ft, _n in type_counts.most_common():
+        ex = examples.get(ft, [])
+        if not ex:
+            continue
+        print(f"\n[{ft}]")
+        for s in ex:
+            print(f"  - {s}")
+
+    print("\nPER-PART DETAILS")
+    for part, instrs in sorted(by_part.items()):
+        print(f"\n== {part} ==")
+        for s in instrs:
+            print(f"- {s}")
+
+    # Quick reminders
+    needs_update = any(ft in type_counts for ft in ("TOC", "REF", "PAGEREF", "NUMPAGES", "PAGE"))
+    if needs_update:
+        print("\nREMINDER")
+        print(
+            "- If the PDF/PNGs show placeholders or wrong page numbers/TOC, open in Word and run: Ctrl+A → F9 (Update Fields), then re-render."
+        )
+
+
+if __name__ == "__main__":
+    main()