winter-super-cli 2026.5.15

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

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""Append the body of one DOCX to another by splicing OOXML.
+
+Why this exists
+---------------
+"Text-only" merges (copying paragraph text) lose most formatting and structure.
+Splicing the OOXML body preserves much more of the original content.
+
+Scope & safety
+--------------
+- Only merges `word/document.xml` body children.
+- Keeps the base document's final `w:sectPr` (section properties).
+- Refuses drawings/images by default because relationships & binary parts are
+  not merged. Use `--allow_drawings` only if you know both documents are
+  compatible and you accept best-effort results.
+
+Usage
+-----
+python scripts/merge_docx_append.py base.docx append.docx --out merged.docx
+python scripts/merge_docx_append.py base.docx append.docx --out merged.docx --allow_drawings
+"""
+
+from __future__ import annotations
+
+import argparse
+import zipfile
+
+from lxml import etree
+
+W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+NS = {"w": W_NS}
+
+
+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 _has_drawings(body: etree._Element) -> bool:
+    return bool(body.xpath(".//w:drawing | .//w:pict", namespaces=NS))
+
+
+def merge(base_docx: str, append_docx: str, out_docx: str, allow_drawings: bool) -> dict[str, int]:
+    with zipfile.ZipFile(base_docx, "r") as zb, zipfile.ZipFile(append_docx, "r") as za:
+        base_root = _read_xml(zb, "word/document.xml")
+        append_root = _read_xml(za, "word/document.xml")
+
+        base_body = base_root.find(f"{{{W_NS}}}body")
+        append_body = append_root.find(f"{{{W_NS}}}body")
+        if base_body is None or append_body is None:
+            raise RuntimeError("Missing w:body in one of the documents")
+
+        if not allow_drawings and _has_drawings(append_body):
+            raise SystemExit(
+                "append.docx contains drawings/images. "
+                "Re-run with --allow_drawings if this is acceptable, "
+                "or remove drawings first to keep the merge safer."
+            )
+
+        # Capture base sectPr (usually the last child of body)
+        base_children = list(base_body)
+        base_sectpr = None
+        if base_children and base_children[-1].tag == f"{{{W_NS}}}sectPr":
+            base_sectpr = base_children[-1]
+            base_body.remove(base_sectpr)
+
+        # Append all children from append body except its trailing sectPr
+        append_children = list(append_body)
+        if append_children and append_children[-1].tag == f"{{{W_NS}}}sectPr":
+            append_children = append_children[:-1]
+
+        inserted = 0
+        for child in append_children:
+            base_body.append(child)
+            inserted += 1
+
+        # Restore base sectPr at end (if any)
+        if base_sectpr is not None:
+            base_body.append(base_sectpr)
+
+        new_document_xml = _xml_bytes(base_root)
+
+        with zipfile.ZipFile(out_docx, "w", zipfile.ZIP_DEFLATED) as zout:
+            for info in zb.infolist():
+                name = info.filename
+                if name == "word/document.xml":
+                    zout.writestr(name, new_document_xml)
+                else:
+                    zout.writestr(name, zb.read(name))
+
+    return {"body_children_appended": inserted}
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("base_docx")
+    ap.add_argument("append_docx")
+    ap.add_argument("--out", required=True)
+    ap.add_argument("--allow_drawings", action="store_true")
+    args = ap.parse_args()
+
+    stats = merge(args.base_docx, args.append_docx, args.out, args.allow_drawings)
+    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/privacy_scrub.py

@@ -0,0 +1,176 @@
+#!/usr/bin/env python3
+"""Remove common personal metadata from a DOCX.
+
+What it does
+------------
+- Clears core properties in docProps/core.xml:
+  - dc:creator
+  - cp:lastModifiedBy
+- Removes docProps/custom.xml (custom properties) if present
+- Removes relationship entries to custom properties if present
+- Removes [Content_Types].xml overrides for removed parts
+- Strips rsid* attributes from story parts (document, headers, footers, footnotes, endnotes)
+
+This does not redact in-document PII; use redact_docx.py for that.
+
+Usage
+-----
+python scripts/privacy_scrub.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"
+
+CP_NS = "http://schemas.openxmlformats.org/package/2006/metadata/core-properties"
+DC_NS = "http://purl.org/dc/elements/1.1/"
+
+NS = {"w": W_NS, "rel": REL_NS, "ct": CT_NS, "cp": CP_NS, "dc": DC_NS}
+
+
+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 = []
+    for name in z.namelist():
+        if name == "word/document.xml":
+            parts.append(name)
+        elif re.match(r"word/header\d+\.xml$", name) or re.match(r"word/footer\d+\.xml$", name):
+            parts.append(name)
+        elif name in ("word/footnotes.xml", "word/endnotes.xml"):
+            parts.append(name)
+    return parts
+
+
+def _strip_rsid_attrs(root: etree._Element) -> int:
+    removed = 0
+    for el in root.iter():
+        # Remove attributes like w:rsidR, w:rsidRDefault, w:rsidP, w:rsidDel, etc.
+        to_del = []
+        for k in el.attrib.keys():
+            if k.startswith(f"{{{W_NS}}}rsid"):
+                to_del.append(k)
+        for k in to_del:
+            del el.attrib[k]
+            removed += 1
+    return removed
+
+
+def _scrub_core_props(core_root: etree._Element) -> bool:
+    changed = False
+    # dc:creator
+    for el in core_root.xpath(".//dc:creator", namespaces=NS):
+        if (el.text or "").strip() != "":
+            el.text = ""
+            changed = True
+    # cp:lastModifiedBy
+    for el in core_root.xpath(".//cp:lastModifiedBy", namespaces=NS):
+        if (el.text or "").strip() != "":
+            el.text = ""
+            changed = True
+    return changed
+
+
+def _remove_custom_rels(rels_root: etree._Element) -> bool:
+    changed = False
+    for rel in list(rels_root.findall(f"{{{REL_NS}}}Relationship")):
+        tgt = rel.get("Target") or ""
+        # docProps/custom.xml is usually targeted as "../docProps/custom.xml" from package rels
+        if tgt.endswith("docProps/custom.xml"):
+            rels_root.remove(rel)
+            changed = True
+    return changed
+
+
+def _remove_custom_ct_override(ct_root: etree._Element) -> bool:
+    changed = False
+    for ov in list(ct_root.findall(f"{{{CT_NS}}}Override")):
+        if (ov.get("PartName") or "") == "/docProps/custom.xml":
+            ct_root.remove(ov)
+            changed = True
+    return changed
+
+
+def scrub(in_docx: str, out_docx: str) -> dict[str, int]:
+    stats = {
+        "rsid_attrs_removed": 0,
+        "core_props_scrubbed": 0,
+        "custom_props_removed": 0,
+        "rels_updated": 0,
+        "content_types_updated": 0,
+    }
+
+    with zipfile.ZipFile(in_docx, "r") as zin:
+        overrides: dict[str, bytes] = {}
+
+        # Story parts: strip rsid attributes
+        for part in _iter_story_parts(zin):
+            root = _read_xml(zin, part)
+            n = _strip_rsid_attrs(root)
+            if n:
+                stats["rsid_attrs_removed"] += n
+                overrides[part] = _xml_bytes(root)
+
+        # Core props
+        if "docProps/core.xml" in zin.namelist():
+            core_root = _read_xml(zin, "docProps/core.xml")
+            if _scrub_core_props(core_root):
+                overrides["docProps/core.xml"] = _xml_bytes(core_root)
+                stats["core_props_scrubbed"] = 1
+
+        # Package rels may reference custom props
+        pkg_rels = "_rels/.rels"
+        if pkg_rels in zin.namelist():
+            rels_root = _read_xml(zin, pkg_rels)
+            if _remove_custom_rels(rels_root):
+                overrides[pkg_rels] = _xml_bytes(rels_root)
+                stats["rels_updated"] = 1
+
+        # Content types override
+        ct_path = "[Content_Types].xml"
+        if ct_path in zin.namelist():
+            ct_root = _read_xml(zin, ct_path)
+            if _remove_custom_ct_override(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 == "docProps/custom.xml":
+                    stats["custom_props_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 = scrub(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/redact_docx.py

@@ -0,0 +1,315 @@
+#!/usr/bin/env python3
+"""Redact/anonymize text in a DOCX while preserving layout as much as possible.
+
+High-level approach
+-------------------
+We patch OOXML directly (document.xml, headers/footers, footnotes/endnotes,
+optionally comments) at the paragraph level:
+
+- Concatenate the paragraph's <w:t> nodes to a single string
+- Apply regex matches against the full string
+- Replace each match with a fixed-length mask (default) so line breaks and pagination are less likely to shift
+- Write the modified string back into the original <w:t> node segmentation
+
+This is *not* a cryptographic anonymization tool; it is a practical helper for "redact this doc for sharing".
+
+Safety defaults
+---------------
+- Default is length-preserving masking (█ repeated) to minimize layout drift.
+- If you supply a replacement string and disable length preservation, expect layout shifts.
+
+"""
+
+from __future__ import annotations
+
+import argparse
+import re
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+
+from lxml import etree
+
+try:
+    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"
+NS = {"w": W_NS}
+XML_SPACE = "{http://www.w3.org/XML/1998/namespace}space"
+
+
+def qn(local: str) -> str:
+    return f"{{{W_NS}}}{local}"
+
+
+@dataclass(frozen=True)
+class RedactionRule:
+    pattern: re.Pattern[str]
+    label: str
+
+
+def _iter_word_parts(unzipped: Path, include_comments: bool) -> list[Path]:
+    word = unzipped / "word"
+    parts: list[Path] = []
+    for name in [
+        "document.xml",
+        "footnotes.xml",
+        "endnotes.xml",
+    ]:
+        p = word / name
+        if p.exists():
+            parts.append(p)
+
+    parts.extend(sorted(word.glob("header*.xml")))
+    parts.extend(sorted(word.glob("footer*.xml")))
+
+    if include_comments:
+        p = word / "comments.xml"
+        if p.exists():
+            parts.append(p)
+
+    return parts
+
+
+def _get_text_nodes_in_paragraph(p: etree._Element) -> list[etree._Element]:
+    return list(p.xpath(".//w:t", namespaces=NS))
+
+
+def _materialize_spaces(t_el: etree._Element) -> None:
+    # Preserve leading/trailing spaces in Word by setting xml:space="preserve".
+    txt = t_el.text or ""
+    if txt.startswith(" ") or txt.endswith(" "):
+        t_el.set(XML_SPACE, "preserve")
+
+
+def _apply_rules_to_paragraph(
+    p: etree._Element,
+    rules: list[RedactionRule],
+    mask_char: str,
+    replacement: str | None,
+    preserve_length: bool,
+) -> int:
+    t_nodes = _get_text_nodes_in_paragraph(p)
+    if not t_nodes:
+        return 0
+
+    original_segments = [n.text or "" for n in t_nodes]
+    full = "".join(original_segments)
+    if not full:
+        return 0
+
+    spans: list[tuple[int, int, str]] = []
+    for rule in rules:
+        for m in rule.pattern.finditer(full):
+            if m.start() == m.end():
+                continue
+            spans.append((m.start(), m.end(), rule.label))
+
+    if not spans:
+        return 0
+
+    # De-overlap: prefer earlier-longer by sorting, then greedily take non-overlapping.
+    spans.sort(key=lambda t: (t[0], -(t[1] - t[0])))
+    chosen: list[tuple[int, int, str]] = []
+    last_end = -1
+    for s, e, lbl in spans:
+        if s < last_end:
+            continue
+        chosen.append((s, e, lbl))
+        last_end = e
+
+    out = list(full)
+    for s, e, _lbl in reversed(chosen):
+        length = e - s
+        if preserve_length:
+            if replacement is None:
+                rep = mask_char * length
+            else:
+                # Repeat/truncate replacement to match length.
+                rep = (replacement * ((length // max(1, len(replacement))) + 1))[:length]
+            out[s:e] = list(rep)
+        else:
+            # Non-length-preserving rewrite: we still write back into the existing
+            # node segmentation by truncating/blanking. Expect layout drift.
+            rep = replacement if replacement is not None else mask_char * length
+            out[s:e] = list(rep)
+
+    new_full = "".join(out)
+
+    if preserve_length and len(new_full) != len(full):
+        raise RuntimeError("Internal error: expected length-preserving rewrite")
+
+    # Write back into the existing node segmentation.
+    idx = 0
+    for node, seg in zip(t_nodes, original_segments, strict=True):
+        take = len(seg)
+        node.text = new_full[idx : idx + take]
+        _materialize_spaces(node)
+        idx += take
+
+    return len(chosen)
+
+
+def redact_docx(
+    input_docx: Path,
+    output_docx: Path,
+    rules: list[RedactionRule],
+    mask_char: str,
+    replacement: str | None,
+    preserve_length: bool,
+    include_comments: bool,
+) -> dict:
+    with tempfile.TemporaryDirectory(prefix="docx_redact_") as td:
+        tmp = Path(td)
+        unzip_docx(input_docx, tmp)
+
+        stats = {
+            "file": str(input_docx),
+            "parts_processed": 0,
+            "paragraphs_touched": 0,
+            "matches_redacted": 0,
+        }
+
+        for part in _iter_word_parts(tmp, include_comments=include_comments):
+            parser = etree.XMLParser(remove_blank_text=False)
+            tree = etree.parse(str(part), parser)
+            root = tree.getroot()
+
+            touched_in_part = 0
+            redactions_in_part = 0
+
+            for p in root.xpath(".//w:p", namespaces=NS):
+                n = _apply_rules_to_paragraph(
+                    p,
+                    rules=rules,
+                    mask_char=mask_char,
+                    replacement=replacement,
+                    preserve_length=preserve_length,
+                )
+                if n:
+                    touched_in_part += 1
+                    redactions_in_part += n
+
+            if redactions_in_part:
+                stats["paragraphs_touched"] += touched_in_part
+                stats["matches_redacted"] += redactions_in_part
+
+            stats["parts_processed"] += 1
+            tree.write(str(part), xml_declaration=True, encoding="UTF-8", standalone="yes")
+
+        zip_docx(tmp, output_docx)
+        return stats
+
+
+def _compile_rules(args: argparse.Namespace) -> list[RedactionRule]:
+    rules: list[RedactionRule] = []
+
+    if args.emails:
+        rules.append(
+            RedactionRule(
+                pattern=re.compile(r"\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b", re.I),
+                label="email",
+            )
+        )
+    if args.phones:
+        rules.append(
+            RedactionRule(
+                pattern=re.compile(
+                    r"(?:(?:\+?\d{1,3}[\s-]?)?(?:\(\d{3}\)|\d{3})[\s-]?)\d{3}[\s-]?\d{4}",
+                    re.I,
+                ),
+                label="phone",
+            )
+        )
+
+    for i, pat in enumerate(args.pattern or []):
+        rules.append(RedactionRule(pattern=re.compile(pat), label=f"custom_{i + 1}"))
+
+    if not rules:
+        raise SystemExit(
+            "No redaction rules specified. Use --emails/--phones and/or --pattern REGEX."
+        )
+    return rules
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description="Redact/anonymize text in a DOCX (OOXML patch).")
+    ap.add_argument("input_docx", type=Path)
+    ap.add_argument("output_docx", type=Path)
+
+    rule = ap.add_argument_group("rules")
+    rule.add_argument("--emails", action="store_true", help="Redact email addresses")
+    rule.add_argument("--phones", action="store_true", help="Redact phone-like numbers")
+    rule.add_argument(
+        "--pattern",
+        action="append",
+        help="Custom regex to redact (can be repeated)",
+    )
+
+    out = ap.add_argument_group("output")
+    out.add_argument(
+        "--mask_char",
+        default="█",
+        help="Mask character for length-preserving redaction (default: █)",
+    )
+    out.add_argument(
+        "--replacement",
+        default=None,
+        help=(
+            "Optional replacement string. If --preserve_length (default), it will be repeated/truncated "
+            "to match each match's length."
+        ),
+    )
+    out.add_argument(
+        "--no_preserve_length",
+        action="store_true",
+        help="Disable length preservation (may cause layout drift)",
+    )
+    out.add_argument(
+        "--include_comments",
+        action="store_true",
+        help="Also redact word/comments.xml (if present)",
+    )
+
+    args = ap.parse_args()
+    rules = _compile_rules(args)
+
+    stats = redact_docx(
+        input_docx=args.input_docx,
+        output_docx=args.output_docx,
+        rules=rules,
+        mask_char=args.mask_char,
+        replacement=args.replacement,
+        preserve_length=not args.no_preserve_length,
+        include_comments=args.include_comments,
+    )
+
+    import json
+
+    print(json.dumps(stats, indent=2))
+
+
+if __name__ == "__main__":
+    main()