winter-super-cli 2026.5.26 → 2026.5.28

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

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

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

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