anymous 1.3.0 → 1.3.2

package/skills/docx/scripts/comment.py

@@ -1,368 +0,0 @@
-"""Add comments to a DOCX document.
-
-Accepts either an unpacked directory OR a .docx/.dotx file directly.
-
-Usage:
-    # Against an unpacked directory (writes satellite files in place)
-    python comment.py unpacked/ "Comment text"
-    python comment.py unpacked/ "Reply text" --parent 0
-
-    # Against a .docx directly (extracts, writes satellite files, rezips)
-    python comment.py contract.docx "This cap is too low" -o annotated.docx
-    python comment.py contract.docx "Comment" --id 5      # explicit ID
-
-The comment ID is auto-assigned (max existing + 1) unless --id is given.
-Plain text is XML-escaped automatically; if you pass already-escaped text
-(e.g. &, ’) use --raw to skip escaping.
-
-After running, add markers to word/document.xml so the comment is visible:
-  <w:commentRangeStart w:id="N"/>
-  ... commented content ...
-  <w:commentRangeEnd w:id="N"/>
-  <w:r><w:rPr><w:rStyle w:val="CommentReference"/></w:rPr><w:commentReference w:id="N"/></w:r>
-"""
-
-import argparse
-import random
-import shutil
-import sys
-import tempfile
-import zipfile
-from datetime import datetime, timezone
-from pathlib import Path
-
-import defusedxml.minidom
-from xml.parsers.expat import ExpatError
-from xml.sax.saxutils import escape as xml_escape
-
-from office.helpers import opc_target, rezip as _rezip, safe_extract as _safe_extract
-
-TEMPLATE_DIR = Path(__file__).parent / "templates"
-NS = {
-    "w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
-    "w14": "http://schemas.microsoft.com/office/word/2010/wordml",
-    "w15": "http://schemas.microsoft.com/office/word/2012/wordml",
-    "w16cid": "http://schemas.microsoft.com/office/word/2016/wordml/cid",
-    "w16cex": "http://schemas.microsoft.com/office/word/2018/wordml/cex",
-}
-
-COMMENT_XML = """\
-<w:comment w:id="{id}" w:author="{author}" w:date="{date}" w:initials="{initials}">
-  <w:p w14:paraId="{para_id}" w14:textId="77777777">
-    <w:r>
-      <w:rPr><w:rStyle w:val="CommentReference"/></w:rPr>
-      <w:annotationRef/>
-    </w:r>
-    <w:r>
-      <w:rPr>
-        <w:color w:val="000000"/>
-        <w:sz w:val="20"/>
-        <w:szCs w:val="20"/>
-      </w:rPr>
-      <w:t xml:space="preserve">{text}</w:t>
-    </w:r>
-  </w:p>
-</w:comment>"""
-
-COMMENT_MARKER_TEMPLATE = """
-Add to word/document.xml (markers must be direct children of w:p, never inside w:r):
-  <w:commentRangeStart w:id="{cid}"/>
-  <w:r>...</w:r>
-  <w:commentRangeEnd w:id="{cid}"/>
-  <w:r><w:rPr><w:rStyle w:val="CommentReference"/></w:rPr><w:commentReference w:id="{cid}"/></w:r>"""
-
-REPLY_MARKER_TEMPLATE = """
-Nest markers inside parent {pid}'s markers (direct children of w:p, never inside w:r):
-  <w:commentRangeStart w:id="{pid}"/><w:commentRangeStart w:id="{cid}"/>
-  <w:r>...</w:r>
-  <w:commentRangeEnd w:id="{cid}"/><w:commentRangeEnd w:id="{pid}"/>
-  <w:r><w:rPr><w:rStyle w:val="CommentReference"/></w:rPr><w:commentReference w:id="{pid}"/></w:r>
-  <w:r><w:rPr><w:rStyle w:val="CommentReference"/></w:rPr><w:commentReference w:id="{cid}"/></w:r>"""
-
-SMART_QUOTE_ENTITIES = {
-    "“": "&#x201C;",
-    "”": "&#x201D;",
-    "‘": "&#x2018;",
-    "’": "&#x2019;",
-}
-
-
-def _generate_hex_id() -> str:
-    return f"{random.randint(0, 0x7FFFFFFE):08X}"
-
-
-def _encode_smart_quotes(text: str) -> str:
-    for char, entity in SMART_QUOTE_ENTITIES.items():
-        text = text.replace(char, entity)
-    return text
-
-
-def _append_xml(xml_path: Path, root_tag: str, content: str) -> None:
-    dom = defusedxml.minidom.parseString(xml_path.read_text(encoding="utf-8"))
-    root = dom.getElementsByTagName(root_tag)[0]
-    ns_attrs = " ".join(f'xmlns:{k}="{v}"' for k, v in NS.items())
-    wrapper_dom = defusedxml.minidom.parseString(f"<root {ns_attrs}>{content}</root>")
-    for child in wrapper_dom.documentElement.childNodes:  
-        if child.nodeType == child.ELEMENT_NODE:
-            root.appendChild(dom.importNode(child, True))
-    output = _encode_smart_quotes(dom.toxml(encoding="UTF-8").decode("utf-8"))
-    xml_path.write_text(output, encoding="utf-8")
-
-
-def _find_para_id(comments_path: Path, comment_id: int) -> str | None:
-    dom = defusedxml.minidom.parseString(comments_path.read_text(encoding="utf-8"))
-    for c in dom.getElementsByTagName("w:comment"):
-        if c.getAttribute("w:id") == str(comment_id):
-            for p in c.getElementsByTagName("w:p"):
-                if pid := p.getAttribute("w14:paraId"):
-                    return pid
-    return None
-
-
-def _next_comment_id(comments_path: Path) -> int:
-    if not comments_path.exists():
-        return 0
-    dom = defusedxml.minidom.parseString(comments_path.read_text(encoding="utf-8"))
-    ids = []
-    for c in dom.getElementsByTagName("w:comment"):
-        try:
-            ids.append(int(c.getAttribute("w:id")))
-        except ValueError:
-            pass
-    return (max(ids) + 1) if ids else 0
-
-
-def _get_next_rid(rels_path: Path) -> int:
-    dom = defusedxml.minidom.parseString(rels_path.read_text(encoding="utf-8"))
-    max_rid = 0
-    for rel in dom.getElementsByTagName("Relationship"):
-        rid = rel.getAttribute("Id")
-        if rid and rid.startswith("rId"):
-            try:
-                max_rid = max(max_rid, int(rid[3:]))
-            except ValueError:
-                pass
-    return max_rid + 1
-
-
-def _has_relationship(rels_path: Path, target: str) -> bool:
-    dom = defusedxml.minidom.parseString(rels_path.read_text(encoding="utf-8"))
-    return any(
-        rel.getAttribute("Target") == target
-        for rel in dom.getElementsByTagName("Relationship")
-    )
-
-
-def _has_content_type(ct_path: Path, part_name: str) -> bool:
-    dom = defusedxml.minidom.parseString(ct_path.read_text(encoding="utf-8"))
-    return any(
-        o.getAttribute("PartName") == part_name
-        for o in dom.getElementsByTagName("Override")
-    )
-
-
-_COMMENT_RELS = [
-    ("http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments", "comments.xml"),
-    ("http://schemas.microsoft.com/office/2011/relationships/commentsExtended", "commentsExtended.xml"),
-    ("http://schemas.microsoft.com/office/2016/09/relationships/commentsIds", "commentsIds.xml"),
-    ("http://schemas.microsoft.com/office/2018/08/relationships/commentsExtensible", "commentsExtensible.xml"),
-]
-_COMMENT_OVERRIDES = [
-    ("/word/comments.xml", "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml"),
-    ("/word/commentsExtended.xml", "application/vnd.openxmlformats-officedocument.wordprocessingml.commentsExtended+xml"),
-    ("/word/commentsIds.xml", "application/vnd.openxmlformats-officedocument.wordprocessingml.commentsIds+xml"),
-    ("/word/commentsExtensible.xml", "application/vnd.openxmlformats-officedocument.wordprocessingml.commentsExtensible+xml"),
-]
-
-
-def _ensure_comment_relationships(unpacked_dir: Path) -> None:
-    rels_path = unpacked_dir / "word" / "_rels" / "document.xml.rels"
-    if not rels_path.exists():
-        return
-    dom = defusedxml.minidom.parseString(rels_path.read_text(encoding="utf-8"))
-    root = dom.documentElement
-    comment_types = {rel_type for rel_type, _ in _COMMENT_RELS}
-    existing = set()
-    for rel in dom.getElementsByTagName("Relationship"):
-        if rel.getAttribute("Type") not in comment_types:
-            continue
-        part = opc_target(
-            rel.getAttribute("Target"),
-            "word/document.xml",
-            rel.getAttribute("TargetMode"),
-        )
-        if part is not None:
-            existing.add(part)
-    next_rid = _get_next_rid(rels_path)
-    changed = False
-    for rel_type, target in _COMMENT_RELS:
-        if opc_target(target, "word/document.xml") in existing:
-            continue
-        rel = dom.createElement("Relationship")
-        rel.setAttribute("Id", f"rId{next_rid}")
-        rel.setAttribute("Type", rel_type)
-        rel.setAttribute("Target", target)
-        root.appendChild(rel)  
-        next_rid += 1
-        changed = True
-    if changed:
-        rels_path.write_bytes(dom.toxml(encoding="UTF-8"))
-
-
-def _ensure_comment_content_types(unpacked_dir: Path) -> None:
-    ct_path = unpacked_dir / "[Content_Types].xml"
-    if not ct_path.exists():
-        return
-    dom = defusedxml.minidom.parseString(ct_path.read_text(encoding="utf-8"))
-    root = dom.documentElement
-    existing = {
-        o.getAttribute("PartName")
-        for o in dom.getElementsByTagName("Override")
-    }
-    changed = False
-    for part_name, content_type in _COMMENT_OVERRIDES:
-        if part_name in existing:
-            continue
-        override = dom.createElement("Override")
-        override.setAttribute("PartName", part_name)
-        override.setAttribute("ContentType", content_type)
-        root.appendChild(override)  
-        changed = True
-    if changed:
-        ct_path.write_bytes(dom.toxml(encoding="UTF-8"))
-
-
-def add_comment(
-    unpacked_dir: Path | str,
-    text: str,
-    comment_id: int | None = None,
-    author: str = "Claude",
-    initials: str = "C",
-    parent_id: int | None = None,
-    raw: bool = False,
-) -> tuple[int, str, str]:
-    unpacked_dir = Path(unpacked_dir)
-    if not raw:
-        text = xml_escape(text)
-    author = xml_escape(author, {'"': "&quot;"})
-    initials = xml_escape(initials, {'"': "&quot;"})
-    word = unpacked_dir / "word"
-    if not word.exists():
-        raise FileNotFoundError(f"{word} not found (not an unpacked .docx?)")
-
-    comments = word / "comments.xml"
-    if comment_id is None:
-        comment_id = _next_comment_id(comments)
-
-    parent_para = None
-    if parent_id is not None:
-        parent_para = _find_para_id(comments, parent_id) if comments.exists() else None
-        if not parent_para:
-            raise ValueError(f"parent comment {parent_id} not found")
-
-    para_id, durable_id = _generate_hex_id(), _generate_hex_id()
-    ts = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
-
-    if not comments.exists():
-        shutil.copy(TEMPLATE_DIR / "comments.xml", comments)
-    _ensure_comment_relationships(unpacked_dir)
-    _ensure_comment_content_types(unpacked_dir)
-    _append_xml(
-        comments,
-        "w:comments",
-        COMMENT_XML.format(
-            id=comment_id, author=author, date=ts, initials=initials,
-            para_id=para_id, text=text,
-        ),
-    )
-
-    ext = word / "commentsExtended.xml"
-    if not ext.exists():
-        shutil.copy(TEMPLATE_DIR / "commentsExtended.xml", ext)
-    if parent_para is not None:
-        _append_xml(
-            ext, "w15:commentsEx",
-            f'<w15:commentEx w15:paraId="{para_id}" w15:paraIdParent="{parent_para}" w15:done="0"/>',
-        )
-    else:
-        _append_xml(
-            ext, "w15:commentsEx",
-            f'<w15:commentEx w15:paraId="{para_id}" w15:done="0"/>',
-        )
-
-    ids = word / "commentsIds.xml"
-    if not ids.exists():
-        shutil.copy(TEMPLATE_DIR / "commentsIds.xml", ids)
-    _append_xml(
-        ids, "w16cid:commentsIds",
-        f'<w16cid:commentId w16cid:paraId="{para_id}" w16cid:durableId="{durable_id}"/>',
-    )
-
-    extensible = word / "commentsExtensible.xml"
-    if not extensible.exists():
-        shutil.copy(TEMPLATE_DIR / "commentsExtensible.xml", extensible)
-    _append_xml(
-        extensible, "w16cex:commentsExtensible",
-        f'<w16cex:commentExtensible w16cex:durableId="{durable_id}" w16cex:dateUtc="{ts}"/>',
-    )
-
-    action = "reply" if parent_id is not None else "comment"
-    return comment_id, para_id, f"Added {action} id={comment_id} (paraId={para_id})"
-
-
-def main() -> None:
-    p = argparse.ArgumentParser(description="Add a comment to a DOCX (directory or .docx file).")
-    p.add_argument("input", help="Unpacked DOCX directory OR a .docx/.dotx file")
-    p.add_argument("text", help="Comment text (plain text; XML-escaped automatically)")
-    p.add_argument("--raw", action="store_true",
-                   help="Treat text as pre-escaped XML (skip automatic escaping)")
-    p.add_argument("--id", type=int, dest="comment_id",
-                   help="Comment ID (default: auto-assign as max existing + 1)")
-    p.add_argument("--author", default="Claude", help="Author name")
-    p.add_argument("--initials", default="C", help="Author initials")
-    p.add_argument("--parent", type=int, help="Parent comment ID (makes this a reply)")
-    p.add_argument("-o", "--output",
-                   help="Output .docx path (only used when input is a .docx; default: overwrite input)")
-    args = p.parse_args()
-
-    src = Path(args.input)
-
-    try:
-        if src.is_dir():
-            if args.output:
-                print("Warning: --output ignored for directory input", file=sys.stderr)
-            cid, _, msg = add_comment(
-                src, args.text, comment_id=args.comment_id,
-                author=args.author, initials=args.initials,
-                parent_id=args.parent, raw=args.raw,
-            )
-            print(msg)
-        elif src.is_file() and src.suffix.lower() in (".docx", ".dotx"):
-            out = Path(args.output) if args.output else src
-            with tempfile.TemporaryDirectory() as tmp:
-                tmp_path = Path(tmp)
-                with zipfile.ZipFile(src) as zf:
-                    _safe_extract(zf, tmp_path)
-                cid, _, msg = add_comment(
-                    tmp_path, args.text, comment_id=args.comment_id,
-                    author=args.author, initials=args.initials,
-                    parent_id=args.parent, raw=args.raw,
-                )
-                _rezip(tmp_path, out)
-            print(msg)
-            print(f"Wrote {out} (comment defined; add markers to word/document.xml to make it visible)")
-        else:
-            print(f"Error: {src} is neither a directory nor a .docx/.dotx file", file=sys.stderr)
-            sys.exit(1)
-    except (FileNotFoundError, ValueError, zipfile.BadZipFile, ExpatError) as e:
-        print(f"Error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-    if args.parent is not None:
-        print(REPLY_MARKER_TEMPLATE.format(pid=args.parent, cid=cid))
-    else:
-        print(COMMENT_MARKER_TEMPLATE.format(cid=cid))
-
-
-if __name__ == "__main__":
-    main()

package/skills/docx/scripts/merge_runs.py

@@ -1,310 +0,0 @@
-"""Merge adjacent identically-formatted runs in a DOCX.
-
-Word fragments paragraph text across many <w:r> elements (revision ids,
-spell-check markers, editing history), which makes find-and-replace on
-word/document.xml unreliable — the string you're looking for is split
-across runs. This coalesces adjacent runs whose formatting (<w:rPr>) is
-identical, strips rsid attributes and proofErr markers, and consolidates the
-text elements — <w:t>, and <w:delText> for text inside a tracked deletion.
-
-Rendering is unchanged. The text you search is what Word draws, which is not
-always the bytes in the file: an element without xml:space="preserve" has its
-edge whitespace trimmed before it reaches the page, so `<w:t>Hello </w:t>`
-followed by `<w:t>world</w:t>` reads "Helloworld" and merges to exactly that.
-
-Runs in two different <w:ins>/<w:del> wrappers are never merged: that would
-rewrite tracked-change structure, collapsing separate revisions into one.
-
-Only word/document.xml is processed (not headers, footers, or footnotes).
-
-Usage:
-    python merge_runs.py unpacked/                  # after unzip, before editing
-    python merge_runs.py document.docx              # rewrite in place
-    python merge_runs.py document.docx -o out.docx
-"""
-
-
-import argparse
-import sys
-import tempfile
-import zipfile
-from pathlib import Path
-
-import defusedxml.minidom
-
-from office.helpers import XML_SPACE, rendered_text, rezip, safe_extract
-
-WORDML_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
-
-
-def merge_runs(input_dir: str) -> tuple[int, str]:
-    doc_xml = Path(input_dir) / "word" / "document.xml"
-
-    if not doc_xml.exists():
-        return 0, f"Error: {doc_xml} not found"
-
-    try:
-        dom = defusedxml.minidom.parseString(doc_xml.read_text(encoding="utf-8"))
-        root = dom.documentElement
-        run_names = _run_tag_names(root)
-
-        _remove_elements(root, "proofErr")
-
-        runs = _find_runs(root, run_names)
-        _strip_rsid_attrs(runs)
-
-        merge_count = 0
-        for container in {run.parentNode for run in runs}:
-            merge_count += _merge_runs_in(container, run_names)
-
-        doc_xml.write_bytes(dom.toxml(encoding="UTF-8"))
-        return merge_count, f"Merged {merge_count} runs"
-
-    except Exception as e:
-        return 0, f"Error: {e}"
-
-
-
-
-def _is_element(node, tag: str) -> bool:
-    name = node.localName or node.tagName
-    return name == tag or name.endswith(f":{tag}")
-
-
-def _run_tag_names(root) -> set[str]:
-    names = set()
-    for attr in root.attributes.values():
-        if attr.value == WORDML_NS:
-            if attr.name == "xmlns":
-                names.add("r")
-            elif attr.name.startswith("xmlns:"):
-                names.add(attr.name.split(":", 1)[1] + ":r")
-    return names or {"w:r", "r"}
-
-
-def _find_elements(root, tag: str) -> list:
-    results = []
-
-    def traverse(node):
-        if node.nodeType == node.ELEMENT_NODE:
-            if _is_element(node, tag):
-                results.append(node)
-            for child in node.childNodes:
-                traverse(child)
-
-    traverse(root)
-    return results
-
-
-def _find_runs(root, run_names: set[str]) -> list:
-    return [e for e in _find_elements(root, "r") if _is_run(e, run_names)]
-
-
-def _get_child(parent, tag: str):
-    return next(iter(_get_children(parent, tag)), None)
-
-
-def _get_children(parent, tag: str) -> list:
-    return [
-        child
-        for child in parent.childNodes
-        if child.nodeType == child.ELEMENT_NODE and _is_element(child, tag)
-    ]
-
-
-def _is_adjacent(elem1, elem2) -> bool:
-    node = elem1.nextSibling
-    while node:
-        if node == elem2:
-            return True
-        if node.nodeType == node.ELEMENT_NODE:
-            return False
-        if node.nodeType == node.TEXT_NODE and node.data.strip(XML_SPACE):
-            return False
-        node = node.nextSibling
-    return False
-
-
-
-
-def _remove_elements(root, tag: str):
-    for elem in _find_elements(root, tag):
-        if elem.parentNode:
-            elem.parentNode.removeChild(elem)
-
-
-def _strip_rsid_attrs(runs: list):
-    for run in runs:
-        for attr in list(run.attributes.values()):
-            if "rsid" in attr.name.lower():
-                run.removeAttribute(attr.name)
-
-
-
-
-def _merge_runs_in(container, run_names: set[str]) -> int:
-    merge_count = 0
-    run = _first_child_run(container, run_names)
-
-    while run:
-        while True:
-            next_elem = _next_element_sibling(run)
-            if next_elem and _is_run(next_elem, run_names) and _can_merge(run, next_elem):
-                _merge_run_content(run, next_elem)
-                container.removeChild(next_elem)
-                merge_count += 1
-            else:
-                break
-
-        _consolidate_text(run)
-        run = _next_sibling_run(run, run_names)
-
-    return merge_count
-
-
-def _first_child_run(container, run_names: set[str]):
-    for child in container.childNodes:
-        if child.nodeType == child.ELEMENT_NODE and _is_run(child, run_names):
-            return child
-    return None
-
-
-def _next_element_sibling(node):
-    sibling = node.nextSibling
-    while sibling:
-        if sibling.nodeType == sibling.ELEMENT_NODE:
-            return sibling
-        sibling = sibling.nextSibling
-    return None
-
-
-def _next_sibling_run(node, run_names: set[str]):
-    sibling = node.nextSibling
-    while sibling:
-        if sibling.nodeType == sibling.ELEMENT_NODE:
-            if _is_run(sibling, run_names):
-                return sibling
-        sibling = sibling.nextSibling
-    return None
-
-
-def _is_run(node, run_names: set[str]) -> bool:
-    return node.tagName in run_names
-
-
-def _can_merge(run1, run2) -> bool:
-    rpr1 = _get_child(run1, "rPr")
-    rpr2 = _get_child(run2, "rPr")
-
-    if (rpr1 is None) != (rpr2 is None):
-        return False
-    if rpr1 is None:
-        return True
-    return rpr1.toxml() == rpr2.toxml()  
-
-
-def _merge_run_content(target, source):
-    for child in list(source.childNodes):
-        if child.nodeType == child.ELEMENT_NODE:
-            name = child.localName or child.tagName
-            if name != "rPr" and not name.endswith(":rPr"):
-                target.appendChild(child)
-
-
-def _element_text(elem) -> str:
-    return "".join(
-        child.data
-        for child in elem.childNodes
-        if child.nodeType in (child.TEXT_NODE, child.CDATA_SECTION_NODE)
-    )
-
-
-def _has_preserve(elem) -> bool:
-    return elem.getAttribute("xml:space") == "preserve"
-
-
-def _rendered_text(elem) -> str:
-    return rendered_text(_element_text(elem), _has_preserve(elem))
-
-
-def _consolidate_text(run):
-    for tag in ("t", "delText"):
-        _consolidate_text_elements(run, tag)
-
-
-def _consolidate_text_elements(run, tag: str):
-    t_elements = _get_children(run, tag)
-
-    for i in range(len(t_elements) - 1, 0, -1):
-        curr, prev = t_elements[i], t_elements[i - 1]
-
-        if _is_adjacent(prev, curr):
-            merged = _rendered_text(prev) + _rendered_text(curr)
-            had_preserve = _has_preserve(prev) or _has_preserve(curr)
-
-            new_text = run.ownerDocument.createTextNode(merged)
-            for node in list(prev.childNodes):
-                if node.nodeType in (node.TEXT_NODE, node.CDATA_SECTION_NODE):
-                    prev.removeChild(node)
-                else:
-                    run.insertBefore(node, curr)
-            prev.appendChild(new_text)
-            for node in list(curr.childNodes):
-                if node.nodeType not in (node.TEXT_NODE, node.CDATA_SECTION_NODE):
-                    run.insertBefore(node, curr)
-
-            if merged != merged.strip(XML_SPACE) or had_preserve:
-                prev.setAttribute("xml:space", "preserve")
-            elif prev.hasAttribute("xml:space"):
-                prev.removeAttribute("xml:space")
-
-            run.removeChild(curr)
-
-
-
-
-def _merge_or_die(path: Path) -> str:
-    _, msg = merge_runs(str(path))
-    if msg.startswith("Error"):
-        print(msg, file=sys.stderr)
-        sys.exit(1)
-    return msg
-
-
-def main() -> None:
-    p = argparse.ArgumentParser(
-        description="Merge adjacent identically-formatted runs in a DOCX (directory or .docx file)."
-    )
-    p.add_argument("input", help="Unpacked DOCX directory OR a .docx/.dotx file")
-    p.add_argument(
-        "-o", "--output",
-        help="Output .docx path (only valid when input is a .docx; default: overwrite input)",
-    )
-    args = p.parse_args()
-
-    src = Path(args.input)
-
-    try:
-        if src.is_dir():
-            if args.output:
-                p.error("--output is only valid for .docx input; directory input is modified in place")
-            print(_merge_or_die(src))
-        elif src.is_file() and src.suffix.lower() in (".docx", ".dotx"):
-            out = Path(args.output) if args.output else src
-            with tempfile.TemporaryDirectory() as tmp:
-                tmp_path = Path(tmp)
-                with zipfile.ZipFile(src) as zf:
-                    safe_extract(zf, tmp_path)
-                msg = _merge_or_die(tmp_path)
-                rezip(tmp_path, out)
-            print(f"{msg}; wrote {out}")
-        else:
-            print(f"Error: {src} is neither a directory nor a .docx/.dotx file", file=sys.stderr)
-            sys.exit(1)
-    except (OSError, ValueError, zipfile.BadZipFile) as e:
-        print(f"Error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()