winter-super-cli 2026.6.22 → 2026.6.23

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

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+"""Remove all comments from a DOCX (ranges + parts).
+
+What it does
+------------
+- Removes comment range markers and references from all story parts:
+  - w:commentRangeStart / w:commentRangeEnd / w:commentReference
+- Removes comment parts if present:
+  - word/comments.xml
+  - word/commentsExtended.xml (newer Word)
+- Removes relationship entries pointing to those parts
+- Removes [Content_Types].xml overrides for comment parts
+
+This is intended for "final" deliverables where the user wants a clean `.docx`.
+
+Usage
+-----
+python scripts/comments_strip.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"
+REL_NS = "http://schemas.openxmlformats.org/package/2006/relationships"
+CT_NS = "http://schemas.openxmlformats.org/package/2006/content-types"
+
+NS = {"w": W_NS, "rel": REL_NS, "ct": CT_NS}
+
+COMMENT_REL_TYPES = {
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments",
+    "http://schemas.microsoft.com/office/2011/relationships/commentsExtended",
+}
+
+
+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 _iter_story_parts(z: zipfile.ZipFile) -> list[str]:
+    parts = ["word/document.xml"]
+    for name in z.namelist():
+        if re.match(r"word/header\d+\.xml$", name) or re.match(r"word/footer\d+\.xml$", name):
+            parts.append(name)
+    return parts
+
+
+def _strip_comment_markup(root: etree._Element) -> int:
+    removed = 0
+    for tag in ["commentRangeStart", "commentRangeEnd", "commentReference"]:
+        els = root.xpath(f".//w:{tag}", namespaces=NS)
+        for el in reversed(els):
+            parent = el.getparent()
+            if parent is not None:
+                parent.remove(el)
+                removed += 1
+    return removed
+
+
+def _remove_comment_relationships(rels_root: etree._Element) -> bool:
+    changed = False
+    for rel in list(rels_root.findall(f"{{{REL_NS}}}Relationship")):
+        if rel.get("Type") in COMMENT_REL_TYPES:
+            rels_root.remove(rel)
+            changed = True
+    return changed
+
+
+def _remove_ct_overrides(ct_root: etree._Element) -> bool:
+    changed = False
+    for ov in list(ct_root.findall(f"{{{CT_NS}}}Override")):
+        pn = ov.get("PartName") or ""
+        if pn in ("/word/comments.xml", "/word/commentsExtended.xml"):
+            ct_root.remove(ov)
+            changed = True
+    return changed
+
+
+def strip_comments(in_docx: str, out_docx: str) -> dict[str, int]:
+    stats = {
+        "markup_removed": 0,
+        "comments_part_removed": 0,
+        "comments_extended_part_removed": 0,
+        "rels_updated": 0,
+        "content_types_updated": 0,
+    }
+
+    with zipfile.ZipFile(in_docx, "r") as zin:
+        overrides: dict[str, bytes] = {}
+
+        for part in _iter_story_parts(zin):
+            root = _read_xml(zin, part)
+            n = _strip_comment_markup(root)
+            if n:
+                stats["markup_removed"] += n
+                overrides[part] = _xml_bytes(root)
+
+        # relationships
+        rels_path = "word/_rels/document.xml.rels"
+        if rels_path in zin.namelist():
+            rels_root = _read_xml(zin, rels_path)
+            if _remove_comment_relationships(rels_root):
+                overrides[rels_path] = _xml_bytes(rels_root)
+                stats["rels_updated"] = 1
+
+        # content types
+        ct_path = "[Content_Types].xml"
+        if ct_path in zin.namelist():
+            ct_root = _read_xml(zin, ct_path)
+            if _remove_ct_overrides(ct_root):
+                overrides[ct_path] = _xml_bytes(ct_root)
+                stats["content_types_updated"] = 1
+
+        with zipfile.ZipFile(out_docx, "w", zipfile.ZIP_DEFLATED) as zout:
+            for info in zin.infolist():
+                name = info.filename
+                if name in ("word/comments.xml", "word/commentsExtended.xml"):
+                    if name.endswith("comments.xml"):
+                        stats["comments_part_removed"] = 1
+                    else:
+                        stats["comments_extended_part_removed"] = 1
+                    continue
+                if name in overrides:
+                    zout.writestr(name, overrides[name])
+                else:
+                    zout.writestr(name, zin.read(name))
+
+    return stats
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("in_docx")
+    ap.add_argument("--out", required=True)
+    args = ap.parse_args()
+
+    stats = strip_comments(args.in_docx, args.out)
+    print(f"[OK] wrote {args.out} | {stats}")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,358 @@
+#!/usr/bin/env python3
+"""Content controls (SDTs) helper.
+
+`python-docx` does not support Word content controls (a.k.a. SDTs / forms).
+This script provides a pragmatic subset:
+
+- list: enumerate SDTs (tag/alias + current visible text)
+- wrap_placeholders: wrap occurrences of `{{TAG}}` in a plain-text SDT tagged TAG
+- fill: set the text of SDTs by tag
+
+Notes
+-----
+- Focuses on plain-text SDTs (`<w:text/>` controls).
+- Wrap works best when placeholders are "leaf" tokens, but the script will split
+  runs when `{{TAG}}` appears inside longer text.
+- By default, we patch `word/document.xml` and also `word/header*.xml`/`word/footer*.xml`.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import tempfile
+from copy import deepcopy
+from pathlib import Path
+
+from lxml import etree
+
+try:
+    # Local helper in this repo.
+    from docx_ooxml_patch import unzip_docx, zip_docx
+except Exception:
+    import os
+    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"
+R_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+NS = {"w": W_NS, "r": R_NS}
+XML_SPACE = "{http://www.w3.org/XML/1998/namespace}space"
+
+PLACEHOLDER_RE = re.compile(r"\{\{([A-Za-z0-9_-]+)\}\}")
+
+
+def qn(local: str) -> str:
+    return f"{{{W_NS}}}{local}"
+
+
+def _preserve_spaces(t_el: etree._Element, text: str) -> None:
+    # Word collapses leading/trailing spaces unless xml:space="preserve".
+    if text.startswith(" ") or text.endswith(" "):
+        t_el.set(XML_SPACE, "preserve")
+
+
+def parse_xml(path: Path) -> etree._ElementTree:
+    parser = etree.XMLParser(remove_blank_text=False)
+    return etree.parse(str(path), parser)
+
+
+def text_of(el: etree._Element) -> str:
+    return "".join(el.xpath(".//w:t/text()", namespaces=NS))
+
+
+def sdt_tag(sdt: etree._Element) -> str:
+    v = sdt.xpath("string(.//w:sdtPr/w:tag/@w:val)", namespaces=NS)
+    return v or ""
+
+
+def sdt_alias(sdt: etree._Element) -> str:
+    v = sdt.xpath("string(.//w:sdtPr/w:alias/@w:val)", namespaces=NS)
+    return v or ""
+
+
+def iter_parts(unzipped: Path, include_headers_footers: bool) -> list[Path]:
+    parts = [unzipped / "word" / "document.xml"]
+    if include_headers_footers:
+        parts += sorted((unzipped / "word").glob("header*.xml"))
+        parts += sorted((unzipped / "word").glob("footer*.xml"))
+    return [p for p in parts if p.exists()]
+
+
+def make_run(text: str, rpr: etree._Element | None) -> etree._Element:
+    r = etree.Element(qn("r"))
+    if rpr is not None:
+        r.append(deepcopy(rpr))
+    t = etree.SubElement(r, qn("t"))
+    t.text = text
+    _preserve_spaces(t, text)
+    return r
+
+
+def make_sdt(tag: str, placeholder_text: str, rpr: etree._Element | None) -> etree._Element:
+    sdt = etree.Element(qn("sdt"))
+
+    sdtPr = etree.SubElement(sdt, qn("sdtPr"))
+    tag_el = etree.SubElement(sdtPr, qn("tag"))
+    tag_el.set(qn("val"), tag)
+    alias_el = etree.SubElement(sdtPr, qn("alias"))
+    alias_el.set(qn("val"), tag)
+    etree.SubElement(sdtPr, qn("text"))  # plain-text content control
+
+    sdtContent = etree.SubElement(sdt, qn("sdtContent"))
+    r = etree.SubElement(sdtContent, qn("r"))
+    if rpr is not None:
+        r.append(deepcopy(rpr))
+    t = etree.SubElement(r, qn("t"))
+    t.text = placeholder_text
+    _preserve_spaces(t, placeholder_text)
+    return sdt
+
+
+def wrap_placeholders_in_tree(root: etree._Element) -> int:
+    """Wrap `{{TAG}}` placeholders found in runs into SDTs.
+
+    Returns number of runs replaced (not number of placeholders).
+    """
+
+    changed = 0
+
+    # We operate on runs; a placeholder may appear within a run across multiple w:t.
+    runs = root.xpath(".//w:r", namespaces=NS)
+    for r in runs:
+        t_nodes = r.xpath("./w:t", namespaces=NS)
+        if not t_nodes:
+            continue
+        full = "".join((t.text or "") for t in t_nodes)
+        if not full or not PLACEHOLDER_RE.search(full):
+            continue
+
+        parent = r.getparent()
+        if parent is None:
+            continue
+
+        rpr = r.find("w:rPr", namespaces=NS)
+        idx = parent.index(r)
+
+        pos = 0
+        inserts: list[etree._Element] = []
+        for m in PLACEHOLDER_RE.finditer(full):
+            if m.start() > pos:
+                inserts.append(make_run(full[pos : m.start()], rpr))
+            tag = m.group(1)
+            inserts.append(make_sdt(tag, m.group(0), rpr))
+            pos = m.end()
+        if pos < len(full):
+            inserts.append(make_run(full[pos:], rpr))
+
+        for node in inserts:
+            parent.insert(idx, node)
+            idx += 1
+        parent.remove(r)
+        changed += 1
+
+    return changed
+
+
+def fill_sdts_in_tree(root: etree._Element, values: dict[str, str]) -> int:
+    """Fill SDTs by tag. Returns number of SDTs updated."""
+
+    updated = 0
+    sdts = root.xpath(".//w:sdt", namespaces=NS)
+    for sdt in sdts:
+        tag = sdt_tag(sdt)
+        if not tag or tag not in values:
+            continue
+        value = values[tag]
+
+        sdtContent = sdt.find("w:sdtContent", namespaces=NS)
+        if sdtContent is None:
+            continue
+
+        # Preserve the first rPr we can find (best-effort).
+        rpr = sdtContent.find(".//w:rPr", namespaces=NS)
+
+        # Determine if this SDT is block-level (contains w:p) or inline.
+        block = bool(sdtContent.findall("w:p", namespaces=NS))
+
+        for child in list(sdtContent):
+            sdtContent.remove(child)
+
+        if block:
+            p = etree.SubElement(sdtContent, qn("p"))
+            r = etree.SubElement(p, qn("r"))
+        else:
+            r = etree.SubElement(sdtContent, qn("r"))
+
+        if rpr is not None:
+            r.append(deepcopy(rpr))
+
+        t = etree.SubElement(r, qn("t"))
+        t.text = value
+        _preserve_spaces(t, value)
+
+        updated += 1
+
+    return updated
+
+
+def cmd_list(docx: Path, include_headers_footers: bool, as_json: bool) -> int:
+    with tempfile.TemporaryDirectory(prefix="docx_sdt_") as td:
+        unz = Path(td) / "unz"
+        unzip_docx(docx, unz)
+
+        rows = []
+        for part in iter_parts(unz, include_headers_footers=include_headers_footers):
+            tree = parse_xml(part)
+            root = tree.getroot()
+            for sdt in root.xpath(".//w:sdt", namespaces=NS):
+                content = sdt.find("w:sdtContent", namespaces=NS)
+                rows.append(
+                    {
+                        "part": str(part.relative_to(unz)),
+                        "tag": sdt_tag(sdt),
+                        "alias": sdt_alias(sdt),
+                        "text": text_of(content if content is not None else sdt),
+                    }
+                )
+        if as_json:
+            print(json.dumps(rows, indent=2, ensure_ascii=False))
+        else:
+            if not rows:
+                print("[content_controls] no SDTs found")
+            for r in rows:
+                tag = r["tag"] or "(no-tag)"
+                alias = r["alias"] or ""
+                txt = r["text"].replace("\n", " ")
+                print(f"- {r['part']}: tag={tag} alias={alias} text={txt}")
+
+    return 0
+
+
+def cmd_wrap(docx: Path, out_docx: Path, include_headers_footers: bool) -> int:
+    with tempfile.TemporaryDirectory(prefix="docx_sdt_") as td:
+        unz = Path(td) / "unz"
+        unzip_docx(docx, unz)
+
+        total = 0
+        for part in iter_parts(unz, include_headers_footers=include_headers_footers):
+            tree = parse_xml(part)
+            root = tree.getroot()
+            total += wrap_placeholders_in_tree(root)
+            tree.write(str(part), xml_declaration=True, encoding="UTF-8", standalone="yes")
+
+        zip_docx(unz, out_docx)
+        print(f"[content_controls] wrapped placeholders in {total} run(s); wrote {out_docx}")
+
+    return 0
+
+
+def _parse_set_args(pairs: list[str]) -> dict[str, str]:
+    out: dict[str, str] = {}
+    for p in pairs:
+        if "=" not in p:
+            raise SystemExit(f"Invalid --set '{p}' (expected TAG=VALUE)")
+        k, v = p.split("=", 1)
+        k = k.strip()
+        if not k:
+            raise SystemExit(f"Invalid --set '{p}' (empty TAG)")
+        out[k] = v
+    return out
+
+
+def cmd_fill(docx: Path, out_docx: Path, include_headers_footers: bool, pairs: list[str]) -> int:
+    values = _parse_set_args(pairs)
+
+    with tempfile.TemporaryDirectory(prefix="docx_sdt_") as td:
+        unz = Path(td) / "unz"
+        unzip_docx(docx, unz)
+
+        total = 0
+        for part in iter_parts(unz, include_headers_footers=include_headers_footers):
+            tree = parse_xml(part)
+            root = tree.getroot()
+            total += fill_sdts_in_tree(root, values)
+            tree.write(str(part), xml_declaration=True, encoding="UTF-8", standalone="yes")
+
+        zip_docx(unz, out_docx)
+        print(f"[content_controls] filled {total} SDT(s); wrote {out_docx}")
+
+    return 0
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description="Work with Word content controls (SDTs) in a DOCX")
+    ap.add_argument("docx", type=Path, help="Input .docx")
+
+    sub = ap.add_subparsers(dest="cmd", required=True)
+
+    ap_list = sub.add_parser("list", help="List SDTs")
+    ap_list.add_argument("--no_headers_footers", action="store_true")
+    ap_list.add_argument("--json", action="store_true", help="JSON output")
+
+    ap_wrap = sub.add_parser("wrap_placeholders", help="Wrap {{TAG}} placeholders into SDTs")
+    ap_wrap.add_argument("--output", required=True, type=Path)
+    ap_wrap.add_argument("--no_headers_footers", action="store_true")
+
+    ap_fill = sub.add_parser("fill", help="Fill SDTs by tag")
+    ap_fill.add_argument("--output", required=True, type=Path)
+    ap_fill.add_argument(
+        "--set",
+        action="append",
+        default=[],
+        help="Set TAG=VALUE (repeatable)",
+    )
+    ap_fill.add_argument("--no_headers_footers", action="store_true")
+
+    args = ap.parse_args()
+
+    if args.cmd == "list":
+        raise SystemExit(
+            cmd_list(
+                args.docx,
+                include_headers_footers=not args.no_headers_footers,
+                as_json=args.json,
+            )
+        )
+    if args.cmd == "wrap_placeholders":
+        raise SystemExit(
+            cmd_wrap(
+                args.docx,
+                args.output,
+                include_headers_footers=not args.no_headers_footers,
+            )
+        )
+    if args.cmd == "fill":
+        if not args.set:
+            raise SystemExit("fill requires at least one --set TAG=VALUE")
+        raise SystemExit(
+            cmd_fill(
+                args.docx,
+                args.output,
+                include_headers_footers=not args.no_headers_footers,
+                pairs=args.set,
+            )
+        )
+
+
+if __name__ == "__main__":
+    main()