winter-super-cli 2026.5.25 → 2026.5.27

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

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

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

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