port-nuker 1.0.1 → 1.0.3

package/.agent/skills/skills/docx-official/scripts/document.py

@@ -1,1276 +0,0 @@
-#!/usr/bin/env python3
-"""
-Library for working with Word documents: comments, tracked changes, and editing.
-
-Usage:
-    from skills.docx.scripts.document import Document
-
-    # Initialize
-    doc = Document('workspace/unpacked')
-    doc = Document('workspace/unpacked', author="John Doe", initials="JD")
-
-    # Find nodes
-    node = doc["word/document.xml"].get_node(tag="w:del", attrs={"w:id": "1"})
-    node = doc["word/document.xml"].get_node(tag="w:p", line_number=10)
-
-    # Add comments
-    doc.add_comment(start=node, end=node, text="Comment text")
-    doc.reply_to_comment(parent_comment_id=0, text="Reply text")
-
-    # Suggest tracked changes
-    doc["word/document.xml"].suggest_deletion(node)  # Delete content
-    doc["word/document.xml"].revert_insertion(ins_node)  # Reject insertion
-    doc["word/document.xml"].revert_deletion(del_node)  # Reject deletion
-
-    # Save
-    doc.save()
-"""
-
-import html
-import random
-import shutil
-import tempfile
-from datetime import datetime, timezone
-from pathlib import Path
-
-from defusedxml import minidom
-from ooxml.scripts.pack import pack_document
-from ooxml.scripts.validation.docx import DOCXSchemaValidator
-from ooxml.scripts.validation.redlining import RedliningValidator
-
-from .utilities import XMLEditor
-
-# Path to template files
-TEMPLATE_DIR = Path(__file__).parent / "templates"
-
-
-class DocxXMLEditor(XMLEditor):
-    """XMLEditor that automatically applies RSID, author, and date to new elements.
-
-    Automatically adds attributes to elements that support them when inserting new content:
-    - w:rsidR, w:rsidRDefault, w:rsidP (for w:p and w:r elements)
-    - w:author and w:date (for w:ins, w:del, w:comment elements)
-    - w:id (for w:ins and w:del elements)
-
-    Attributes:
-        dom (defusedxml.minidom.Document): The DOM document for direct manipulation
-    """
-
-    def __init__(
-        self, xml_path, rsid: str, author: str = "Claude", initials: str = "C"
-    ):
-        """Initialize with required RSID and optional author.
-
-        Args:
-            xml_path: Path to XML file to edit
-            rsid: RSID to automatically apply to new elements
-            author: Author name for tracked changes and comments (default: "Claude")
-            initials: Author initials (default: "C")
-        """
-        super().__init__(xml_path)
-        self.rsid = rsid
-        self.author = author
-        self.initials = initials
-
-    def _get_next_change_id(self):
-        """Get the next available change ID by checking all tracked change elements."""
-        max_id = -1
-        for tag in ("w:ins", "w:del"):
-            elements = self.dom.getElementsByTagName(tag)
-            for elem in elements:
-                change_id = elem.getAttribute("w:id")
-                if change_id:
-                    try:
-                        max_id = max(max_id, int(change_id))
-                    except ValueError:
-                        pass
-        return max_id + 1
-
-    def _ensure_w16du_namespace(self):
-        """Ensure w16du namespace is declared on the root element."""
-        root = self.dom.documentElement
-        if not root.hasAttribute("xmlns:w16du"):  # type: ignore
-            root.setAttribute(  # type: ignore
-                "xmlns:w16du",
-                "http://schemas.microsoft.com/office/word/2023/wordml/word16du",
-            )
-
-    def _ensure_w16cex_namespace(self):
-        """Ensure w16cex namespace is declared on the root element."""
-        root = self.dom.documentElement
-        if not root.hasAttribute("xmlns:w16cex"):  # type: ignore
-            root.setAttribute(  # type: ignore
-                "xmlns:w16cex",
-                "http://schemas.microsoft.com/office/word/2018/wordml/cex",
-            )
-
-    def _ensure_w14_namespace(self):
-        """Ensure w14 namespace is declared on the root element."""
-        root = self.dom.documentElement
-        if not root.hasAttribute("xmlns:w14"):  # type: ignore
-            root.setAttribute(  # type: ignore
-                "xmlns:w14",
-                "http://schemas.microsoft.com/office/word/2010/wordml",
-            )
-
-    def _inject_attributes_to_nodes(self, nodes):
-        """Inject RSID, author, and date attributes into DOM nodes where applicable.
-
-        Adds attributes to elements that support them:
-        - w:r: gets w:rsidR (or w:rsidDel if inside w:del)
-        - w:p: gets w:rsidR, w:rsidRDefault, w:rsidP, w14:paraId, w14:textId
-        - w:t: gets xml:space="preserve" if text has leading/trailing whitespace
-        - w:ins, w:del: get w:id, w:author, w:date, w16du:dateUtc
-        - w:comment: gets w:author, w:date, w:initials
-        - w16cex:commentExtensible: gets w16cex:dateUtc
-
-        Args:
-            nodes: List of DOM nodes to process
-        """
-        from datetime import datetime, timezone
-
-        timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
-
-        def is_inside_deletion(elem):
-            """Check if element is inside a w:del element."""
-            parent = elem.parentNode
-            while parent:
-                if parent.nodeType == parent.ELEMENT_NODE and parent.tagName == "w:del":
-                    return True
-                parent = parent.parentNode
-            return False
-
-        def add_rsid_to_p(elem):
-            if not elem.hasAttribute("w:rsidR"):
-                elem.setAttribute("w:rsidR", self.rsid)
-            if not elem.hasAttribute("w:rsidRDefault"):
-                elem.setAttribute("w:rsidRDefault", self.rsid)
-            if not elem.hasAttribute("w:rsidP"):
-                elem.setAttribute("w:rsidP", self.rsid)
-            # Add w14:paraId and w14:textId if not present
-            if not elem.hasAttribute("w14:paraId"):
-                self._ensure_w14_namespace()
-                elem.setAttribute("w14:paraId", _generate_hex_id())
-            if not elem.hasAttribute("w14:textId"):
-                self._ensure_w14_namespace()
-                elem.setAttribute("w14:textId", _generate_hex_id())
-
-        def add_rsid_to_r(elem):
-            # Use w:rsidDel for <w:r> inside <w:del>, otherwise w:rsidR
-            if is_inside_deletion(elem):
-                if not elem.hasAttribute("w:rsidDel"):
-                    elem.setAttribute("w:rsidDel", self.rsid)
-            else:
-                if not elem.hasAttribute("w:rsidR"):
-                    elem.setAttribute("w:rsidR", self.rsid)
-
-        def add_tracked_change_attrs(elem):
-            # Auto-assign w:id if not present
-            if not elem.hasAttribute("w:id"):
-                elem.setAttribute("w:id", str(self._get_next_change_id()))
-            if not elem.hasAttribute("w:author"):
-                elem.setAttribute("w:author", self.author)
-            if not elem.hasAttribute("w:date"):
-                elem.setAttribute("w:date", timestamp)
-            # Add w16du:dateUtc for tracked changes (same as w:date since we generate UTC timestamps)
-            if elem.tagName in ("w:ins", "w:del") and not elem.hasAttribute(
-                "w16du:dateUtc"
-            ):
-                self._ensure_w16du_namespace()
-                elem.setAttribute("w16du:dateUtc", timestamp)
-
-        def add_comment_attrs(elem):
-            if not elem.hasAttribute("w:author"):
-                elem.setAttribute("w:author", self.author)
-            if not elem.hasAttribute("w:date"):
-                elem.setAttribute("w:date", timestamp)
-            if not elem.hasAttribute("w:initials"):
-                elem.setAttribute("w:initials", self.initials)
-
-        def add_comment_extensible_date(elem):
-            # Add w16cex:dateUtc for comment extensible elements
-            if not elem.hasAttribute("w16cex:dateUtc"):
-                self._ensure_w16cex_namespace()
-                elem.setAttribute("w16cex:dateUtc", timestamp)
-
-        def add_xml_space_to_t(elem):
-            # Add xml:space="preserve" to w:t if text has leading/trailing whitespace
-            if (
-                elem.firstChild
-                and elem.firstChild.nodeType == elem.firstChild.TEXT_NODE
-            ):
-                text = elem.firstChild.data
-                if text and (text[0].isspace() or text[-1].isspace()):
-                    if not elem.hasAttribute("xml:space"):
-                        elem.setAttribute("xml:space", "preserve")
-
-        for node in nodes:
-            if node.nodeType != node.ELEMENT_NODE:
-                continue
-
-            # Handle the node itself
-            if node.tagName == "w:p":
-                add_rsid_to_p(node)
-            elif node.tagName == "w:r":
-                add_rsid_to_r(node)
-            elif node.tagName == "w:t":
-                add_xml_space_to_t(node)
-            elif node.tagName in ("w:ins", "w:del"):
-                add_tracked_change_attrs(node)
-            elif node.tagName == "w:comment":
-                add_comment_attrs(node)
-            elif node.tagName == "w16cex:commentExtensible":
-                add_comment_extensible_date(node)
-
-            # Process descendants (getElementsByTagName doesn't return the element itself)
-            for elem in node.getElementsByTagName("w:p"):
-                add_rsid_to_p(elem)
-            for elem in node.getElementsByTagName("w:r"):
-                add_rsid_to_r(elem)
-            for elem in node.getElementsByTagName("w:t"):
-                add_xml_space_to_t(elem)
-            for tag in ("w:ins", "w:del"):
-                for elem in node.getElementsByTagName(tag):
-                    add_tracked_change_attrs(elem)
-            for elem in node.getElementsByTagName("w:comment"):
-                add_comment_attrs(elem)
-            for elem in node.getElementsByTagName("w16cex:commentExtensible"):
-                add_comment_extensible_date(elem)
-
-    def replace_node(self, elem, new_content):
-        """Replace node with automatic attribute injection."""
-        nodes = super().replace_node(elem, new_content)
-        self._inject_attributes_to_nodes(nodes)
-        return nodes
-
-    def insert_after(self, elem, xml_content):
-        """Insert after with automatic attribute injection."""
-        nodes = super().insert_after(elem, xml_content)
-        self._inject_attributes_to_nodes(nodes)
-        return nodes
-
-    def insert_before(self, elem, xml_content):
-        """Insert before with automatic attribute injection."""
-        nodes = super().insert_before(elem, xml_content)
-        self._inject_attributes_to_nodes(nodes)
-        return nodes
-
-    def append_to(self, elem, xml_content):
-        """Append to with automatic attribute injection."""
-        nodes = super().append_to(elem, xml_content)
-        self._inject_attributes_to_nodes(nodes)
-        return nodes
-
-    def revert_insertion(self, elem):
-        """Reject an insertion by wrapping its content in a deletion.
-
-        Wraps all runs inside w:ins in w:del, converting w:t to w:delText.
-        Can process a single w:ins element or a container element with multiple w:ins.
-
-        Args:
-            elem: Element to process (w:ins, w:p, w:body, etc.)
-
-        Returns:
-            list: List containing the processed element(s)
-
-        Raises:
-            ValueError: If the element contains no w:ins elements
-
-        Example:
-            # Reject a single insertion
-            ins = doc["word/document.xml"].get_node(tag="w:ins", attrs={"w:id": "5"})
-            doc["word/document.xml"].revert_insertion(ins)
-
-            # Reject all insertions in a paragraph
-            para = doc["word/document.xml"].get_node(tag="w:p", line_number=42)
-            doc["word/document.xml"].revert_insertion(para)
-        """
-        # Collect insertions
-        ins_elements = []
-        if elem.tagName == "w:ins":
-            ins_elements.append(elem)
-        else:
-            ins_elements.extend(elem.getElementsByTagName("w:ins"))
-
-        # Validate that there are insertions to reject
-        if not ins_elements:
-            raise ValueError(
-                f"revert_insertion requires w:ins elements. "
-                f"The provided element <{elem.tagName}> contains no insertions. "
-            )
-
-        # Process all insertions - wrap all children in w:del
-        for ins_elem in ins_elements:
-            runs = list(ins_elem.getElementsByTagName("w:r"))
-            if not runs:
-                continue
-
-            # Create deletion wrapper
-            del_wrapper = self.dom.createElement("w:del")
-
-            # Process each run
-            for run in runs:
-                # Convert w:t → w:delText and w:rsidR → w:rsidDel
-                if run.hasAttribute("w:rsidR"):
-                    run.setAttribute("w:rsidDel", run.getAttribute("w:rsidR"))
-                    run.removeAttribute("w:rsidR")
-                elif not run.hasAttribute("w:rsidDel"):
-                    run.setAttribute("w:rsidDel", self.rsid)
-
-                for t_elem in list(run.getElementsByTagName("w:t")):
-                    del_text = self.dom.createElement("w:delText")
-                    # Copy ALL child nodes (not just firstChild) to handle entities
-                    while t_elem.firstChild:
-                        del_text.appendChild(t_elem.firstChild)
-                    for i in range(t_elem.attributes.length):
-                        attr = t_elem.attributes.item(i)
-                        del_text.setAttribute(attr.name, attr.value)
-                    t_elem.parentNode.replaceChild(del_text, t_elem)
-
-            # Move all children from ins to del wrapper
-            while ins_elem.firstChild:
-                del_wrapper.appendChild(ins_elem.firstChild)
-
-            # Add del wrapper back to ins
-            ins_elem.appendChild(del_wrapper)
-
-            # Inject attributes to the deletion wrapper
-            self._inject_attributes_to_nodes([del_wrapper])
-
-        return [elem]
-
-    def revert_deletion(self, elem):
-        """Reject a deletion by re-inserting the deleted content.
-
-        Creates w:ins elements after each w:del, copying deleted content and
-        converting w:delText back to w:t.
-        Can process a single w:del element or a container element with multiple w:del.
-
-        Args:
-            elem: Element to process (w:del, w:p, w:body, etc.)
-
-        Returns:
-            list: If elem is w:del, returns [elem, new_ins]. Otherwise returns [elem].
-
-        Raises:
-            ValueError: If the element contains no w:del elements
-
-        Example:
-            # Reject a single deletion - returns [w:del, w:ins]
-            del_elem = doc["word/document.xml"].get_node(tag="w:del", attrs={"w:id": "3"})
-            nodes = doc["word/document.xml"].revert_deletion(del_elem)
-
-            # Reject all deletions in a paragraph - returns [para]
-            para = doc["word/document.xml"].get_node(tag="w:p", line_number=42)
-            nodes = doc["word/document.xml"].revert_deletion(para)
-        """
-        # Collect deletions FIRST - before we modify the DOM
-        del_elements = []
-        is_single_del = elem.tagName == "w:del"
-
-        if is_single_del:
-            del_elements.append(elem)
-        else:
-            del_elements.extend(elem.getElementsByTagName("w:del"))
-
-        # Validate that there are deletions to reject
-        if not del_elements:
-            raise ValueError(
-                f"revert_deletion requires w:del elements. "
-                f"The provided element <{elem.tagName}> contains no deletions. "
-            )
-
-        # Track created insertion (only relevant if elem is a single w:del)
-        created_insertion = None
-
-        # Process all deletions - create insertions that copy the deleted content
-        for del_elem in del_elements:
-            # Clone the deleted runs and convert them to insertions
-            runs = list(del_elem.getElementsByTagName("w:r"))
-            if not runs:
-                continue
-
-            # Create insertion wrapper
-            ins_elem = self.dom.createElement("w:ins")
-
-            for run in runs:
-                # Clone the run
-                new_run = run.cloneNode(True)
-
-                # Convert w:delText → w:t
-                for del_text in list(new_run.getElementsByTagName("w:delText")):
-                    t_elem = self.dom.createElement("w:t")
-                    # Copy ALL child nodes (not just firstChild) to handle entities
-                    while del_text.firstChild:
-                        t_elem.appendChild(del_text.firstChild)
-                    for i in range(del_text.attributes.length):
-                        attr = del_text.attributes.item(i)
-                        t_elem.setAttribute(attr.name, attr.value)
-                    del_text.parentNode.replaceChild(t_elem, del_text)
-
-                # Update run attributes: w:rsidDel → w:rsidR
-                if new_run.hasAttribute("w:rsidDel"):
-                    new_run.setAttribute("w:rsidR", new_run.getAttribute("w:rsidDel"))
-                    new_run.removeAttribute("w:rsidDel")
-                elif not new_run.hasAttribute("w:rsidR"):
-                    new_run.setAttribute("w:rsidR", self.rsid)
-
-                ins_elem.appendChild(new_run)
-
-            # Insert the new insertion after the deletion
-            nodes = self.insert_after(del_elem, ins_elem.toxml())
-
-            # If processing a single w:del, track the created insertion
-            if is_single_del and nodes:
-                created_insertion = nodes[0]
-
-        # Return based on input type
-        if is_single_del and created_insertion:
-            return [elem, created_insertion]
-        else:
-            return [elem]
-
-    @staticmethod
-    def suggest_paragraph(xml_content: str) -> str:
-        """Transform paragraph XML to add tracked change wrapping for insertion.
-
-        Wraps runs in <w:ins> and adds <w:ins/> to w:rPr in w:pPr for numbered lists.
-
-        Args:
-            xml_content: XML string containing a <w:p> element
-
-        Returns:
-            str: Transformed XML with tracked change wrapping
-        """
-        wrapper = f'<root xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">{xml_content}</root>'
-        doc = minidom.parseString(wrapper)
-        para = doc.getElementsByTagName("w:p")[0]
-
-        # Ensure w:pPr exists
-        pPr_list = para.getElementsByTagName("w:pPr")
-        if not pPr_list:
-            pPr = doc.createElement("w:pPr")
-            para.insertBefore(
-                pPr, para.firstChild
-            ) if para.firstChild else para.appendChild(pPr)
-        else:
-            pPr = pPr_list[0]
-
-        # Ensure w:rPr exists in w:pPr
-        rPr_list = pPr.getElementsByTagName("w:rPr")
-        if not rPr_list:
-            rPr = doc.createElement("w:rPr")
-            pPr.appendChild(rPr)
-        else:
-            rPr = rPr_list[0]
-
-        # Add <w:ins/> to w:rPr
-        ins_marker = doc.createElement("w:ins")
-        rPr.insertBefore(
-            ins_marker, rPr.firstChild
-        ) if rPr.firstChild else rPr.appendChild(ins_marker)
-
-        # Wrap all non-pPr children in <w:ins>
-        ins_wrapper = doc.createElement("w:ins")
-        for child in [c for c in para.childNodes if c.nodeName != "w:pPr"]:
-            para.removeChild(child)
-            ins_wrapper.appendChild(child)
-        para.appendChild(ins_wrapper)
-
-        return para.toxml()
-
-    def suggest_deletion(self, elem):
-        """Mark a w:r or w:p element as deleted with tracked changes (in-place DOM manipulation).
-
-        For w:r: wraps in <w:del>, converts <w:t> to <w:delText>, preserves w:rPr
-        For w:p (regular): wraps content in <w:del>, converts <w:t> to <w:delText>
-        For w:p (numbered list): adds <w:del/> to w:rPr in w:pPr, wraps content in <w:del>
-
-        Args:
-            elem: A w:r or w:p DOM element without existing tracked changes
-
-        Returns:
-            Element: The modified element
-
-        Raises:
-            ValueError: If element has existing tracked changes or invalid structure
-        """
-        if elem.nodeName == "w:r":
-            # Check for existing w:delText
-            if elem.getElementsByTagName("w:delText"):
-                raise ValueError("w:r element already contains w:delText")
-
-            # Convert w:t → w:delText
-            for t_elem in list(elem.getElementsByTagName("w:t")):
-                del_text = self.dom.createElement("w:delText")
-                # Copy ALL child nodes (not just firstChild) to handle entities
-                while t_elem.firstChild:
-                    del_text.appendChild(t_elem.firstChild)
-                # Preserve attributes like xml:space
-                for i in range(t_elem.attributes.length):
-                    attr = t_elem.attributes.item(i)
-                    del_text.setAttribute(attr.name, attr.value)
-                t_elem.parentNode.replaceChild(del_text, t_elem)
-
-            # Update run attributes: w:rsidR → w:rsidDel
-            if elem.hasAttribute("w:rsidR"):
-                elem.setAttribute("w:rsidDel", elem.getAttribute("w:rsidR"))
-                elem.removeAttribute("w:rsidR")
-            elif not elem.hasAttribute("w:rsidDel"):
-                elem.setAttribute("w:rsidDel", self.rsid)
-
-            # Wrap in w:del
-            del_wrapper = self.dom.createElement("w:del")
-            parent = elem.parentNode
-            parent.insertBefore(del_wrapper, elem)
-            parent.removeChild(elem)
-            del_wrapper.appendChild(elem)
-
-            # Inject attributes to the deletion wrapper
-            self._inject_attributes_to_nodes([del_wrapper])
-
-            return del_wrapper
-
-        elif elem.nodeName == "w:p":
-            # Check for existing tracked changes
-            if elem.getElementsByTagName("w:ins") or elem.getElementsByTagName("w:del"):
-                raise ValueError("w:p element already contains tracked changes")
-
-            # Check if it's a numbered list item
-            pPr_list = elem.getElementsByTagName("w:pPr")
-            is_numbered = pPr_list and pPr_list[0].getElementsByTagName("w:numPr")
-
-            if is_numbered:
-                # Add <w:del/> to w:rPr in w:pPr
-                pPr = pPr_list[0]
-                rPr_list = pPr.getElementsByTagName("w:rPr")
-
-                if not rPr_list:
-                    rPr = self.dom.createElement("w:rPr")
-                    pPr.appendChild(rPr)
-                else:
-                    rPr = rPr_list[0]
-
-                # Add <w:del/> marker
-                del_marker = self.dom.createElement("w:del")
-                rPr.insertBefore(
-                    del_marker, rPr.firstChild
-                ) if rPr.firstChild else rPr.appendChild(del_marker)
-
-            # Convert w:t → w:delText in all runs
-            for t_elem in list(elem.getElementsByTagName("w:t")):
-                del_text = self.dom.createElement("w:delText")
-                # Copy ALL child nodes (not just firstChild) to handle entities
-                while t_elem.firstChild:
-                    del_text.appendChild(t_elem.firstChild)
-                # Preserve attributes like xml:space
-                for i in range(t_elem.attributes.length):
-                    attr = t_elem.attributes.item(i)
-                    del_text.setAttribute(attr.name, attr.value)
-                t_elem.parentNode.replaceChild(del_text, t_elem)
-
-            # Update run attributes: w:rsidR → w:rsidDel
-            for run in elem.getElementsByTagName("w:r"):
-                if run.hasAttribute("w:rsidR"):
-                    run.setAttribute("w:rsidDel", run.getAttribute("w:rsidR"))
-                    run.removeAttribute("w:rsidR")
-                elif not run.hasAttribute("w:rsidDel"):
-                    run.setAttribute("w:rsidDel", self.rsid)
-
-            # Wrap all non-pPr children in <w:del>
-            del_wrapper = self.dom.createElement("w:del")
-            for child in [c for c in elem.childNodes if c.nodeName != "w:pPr"]:
-                elem.removeChild(child)
-                del_wrapper.appendChild(child)
-            elem.appendChild(del_wrapper)
-
-            # Inject attributes to the deletion wrapper
-            self._inject_attributes_to_nodes([del_wrapper])
-
-            return elem
-
-        else:
-            raise ValueError(f"Element must be w:r or w:p, got {elem.nodeName}")
-
-
-def _generate_hex_id() -> str:
-    """Generate random 8-character hex ID for para/durable IDs.
-
-    Values are constrained to be less than 0x7FFFFFFF per OOXML spec:
-    - paraId must be < 0x80000000
-    - durableId must be < 0x7FFFFFFF
-    We use the stricter constraint (0x7FFFFFFF) for both.
-    """
-    return f"{random.randint(1, 0x7FFFFFFE):08X}"
-
-
-def _generate_rsid() -> str:
-    """Generate random 8-character hex RSID."""
-    return "".join(random.choices("0123456789ABCDEF", k=8))
-
-
-class Document:
-    """Manages comments in unpacked Word documents."""
-
-    def __init__(
-        self,
-        unpacked_dir,
-        rsid=None,
-        track_revisions=False,
-        author="Claude",
-        initials="C",
-    ):
-        """
-        Initialize with path to unpacked Word document directory.
-        Automatically sets up comment infrastructure (people.xml, RSIDs).
-
-        Args:
-            unpacked_dir: Path to unpacked DOCX directory (must contain word/ subdirectory)
-            rsid: Optional RSID to use for all comment elements. If not provided, one will be generated.
-            track_revisions: If True, enables track revisions in settings.xml (default: False)
-            author: Default author name for comments (default: "Claude")
-            initials: Default author initials for comments (default: "C")
-        """
-        self.original_path = Path(unpacked_dir)
-
-        if not self.original_path.exists() or not self.original_path.is_dir():
-            raise ValueError(f"Directory not found: {unpacked_dir}")
-
-        # Create temporary directory with subdirectories for unpacked content and baseline
-        self.temp_dir = tempfile.mkdtemp(prefix="docx_")
-        self.unpacked_path = Path(self.temp_dir) / "unpacked"
-        shutil.copytree(self.original_path, self.unpacked_path)
-
-        # Pack original directory into temporary .docx for validation baseline (outside unpacked dir)
-        self.original_docx = Path(self.temp_dir) / "original.docx"
-        pack_document(self.original_path, self.original_docx, validate=False)
-
-        self.word_path = self.unpacked_path / "word"
-
-        # Generate RSID if not provided
-        self.rsid = rsid if rsid else _generate_rsid()
-        print(f"Using RSID: {self.rsid}")
-
-        # Set default author and initials
-        self.author = author
-        self.initials = initials
-
-        # Cache for lazy-loaded editors
-        self._editors = {}
-
-        # Comment file paths
-        self.comments_path = self.word_path / "comments.xml"
-        self.comments_extended_path = self.word_path / "commentsExtended.xml"
-        self.comments_ids_path = self.word_path / "commentsIds.xml"
-        self.comments_extensible_path = self.word_path / "commentsExtensible.xml"
-
-        # Load existing comments and determine next ID (before setup modifies files)
-        self.existing_comments = self._load_existing_comments()
-        self.next_comment_id = self._get_next_comment_id()
-
-        # Convenient access to document.xml editor (semi-private)
-        self._document = self["word/document.xml"]
-
-        # Setup tracked changes infrastructure
-        self._setup_tracking(track_revisions=track_revisions)
-
-        # Add author to people.xml
-        self._add_author_to_people(author)
-
-    def __getitem__(self, xml_path: str) -> DocxXMLEditor:
-        """
-        Get or create a DocxXMLEditor for the specified XML file.
-
-        Enables lazy-loaded editors with bracket notation:
-            node = doc["word/document.xml"].get_node(tag="w:p", line_number=42)
-
-        Args:
-            xml_path: Relative path to XML file (e.g., "word/document.xml", "word/comments.xml")
-
-        Returns:
-            DocxXMLEditor instance for the specified file
-
-        Raises:
-            ValueError: If the file does not exist
-
-        Example:
-            # Get node from document.xml
-            node = doc["word/document.xml"].get_node(tag="w:del", attrs={"w:id": "1"})
-
-            # Get node from comments.xml
-            comment = doc["word/comments.xml"].get_node(tag="w:comment", attrs={"w:id": "0"})
-        """
-        if xml_path not in self._editors:
-            file_path = self.unpacked_path / xml_path
-            if not file_path.exists():
-                raise ValueError(f"XML file not found: {xml_path}")
-            # Use DocxXMLEditor with RSID, author, and initials for all editors
-            self._editors[xml_path] = DocxXMLEditor(
-                file_path, rsid=self.rsid, author=self.author, initials=self.initials
-            )
-        return self._editors[xml_path]
-
-    def add_comment(self, start, end, text: str) -> int:
-        """
-        Add a comment spanning from one element to another.
-
-        Args:
-            start: DOM element for the starting point
-            end: DOM element for the ending point
-            text: Comment content
-
-        Returns:
-            The comment ID that was created
-
-        Example:
-            start_node = cm.get_document_node(tag="w:del", id="1")
-            end_node = cm.get_document_node(tag="w:ins", id="2")
-            cm.add_comment(start=start_node, end=end_node, text="Explanation")
-        """
-        comment_id = self.next_comment_id
-        para_id = _generate_hex_id()
-        durable_id = _generate_hex_id()
-        timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
-
-        # Add comment ranges to document.xml immediately
-        self._document.insert_before(start, self._comment_range_start_xml(comment_id))
-
-        # If end node is a paragraph, append comment markup inside it
-        # Otherwise insert after it (for run-level anchors)
-        if end.tagName == "w:p":
-            self._document.append_to(end, self._comment_range_end_xml(comment_id))
-        else:
-            self._document.insert_after(end, self._comment_range_end_xml(comment_id))
-
-        # Add to comments.xml immediately
-        self._add_to_comments_xml(
-            comment_id, para_id, text, self.author, self.initials, timestamp
-        )
-
-        # Add to commentsExtended.xml immediately
-        self._add_to_comments_extended_xml(para_id, parent_para_id=None)
-
-        # Add to commentsIds.xml immediately
-        self._add_to_comments_ids_xml(para_id, durable_id)
-
-        # Add to commentsExtensible.xml immediately
-        self._add_to_comments_extensible_xml(durable_id)
-
-        # Update existing_comments so replies work
-        self.existing_comments[comment_id] = {"para_id": para_id}
-
-        self.next_comment_id += 1
-        return comment_id
-
-    def reply_to_comment(
-        self,
-        parent_comment_id: int,
-        text: str,
-    ) -> int:
-        """
-        Add a reply to an existing comment.
-
-        Args:
-            parent_comment_id: The w:id of the parent comment to reply to
-            text: Reply text
-
-        Returns:
-            The comment ID that was created for the reply
-
-        Example:
-            cm.reply_to_comment(parent_comment_id=0, text="I agree with this change")
-        """
-        if parent_comment_id not in self.existing_comments:
-            raise ValueError(f"Parent comment with id={parent_comment_id} not found")
-
-        parent_info = self.existing_comments[parent_comment_id]
-        comment_id = self.next_comment_id
-        para_id = _generate_hex_id()
-        durable_id = _generate_hex_id()
-        timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
-
-        # Add comment ranges to document.xml immediately
-        parent_start_elem = self._document.get_node(
-            tag="w:commentRangeStart", attrs={"w:id": str(parent_comment_id)}
-        )
-        parent_ref_elem = self._document.get_node(
-            tag="w:commentReference", attrs={"w:id": str(parent_comment_id)}
-        )
-
-        self._document.insert_after(
-            parent_start_elem, self._comment_range_start_xml(comment_id)
-        )
-        parent_ref_run = parent_ref_elem.parentNode
-        self._document.insert_after(
-            parent_ref_run, f'<w:commentRangeEnd w:id="{comment_id}"/>'
-        )
-        self._document.insert_after(
-            parent_ref_run, self._comment_ref_run_xml(comment_id)
-        )
-
-        # Add to comments.xml immediately
-        self._add_to_comments_xml(
-            comment_id, para_id, text, self.author, self.initials, timestamp
-        )
-
-        # Add to commentsExtended.xml immediately (with parent)
-        self._add_to_comments_extended_xml(
-            para_id, parent_para_id=parent_info["para_id"]
-        )
-
-        # Add to commentsIds.xml immediately
-        self._add_to_comments_ids_xml(para_id, durable_id)
-
-        # Add to commentsExtensible.xml immediately
-        self._add_to_comments_extensible_xml(durable_id)
-
-        # Update existing_comments so replies work
-        self.existing_comments[comment_id] = {"para_id": para_id}
-
-        self.next_comment_id += 1
-        return comment_id
-
-    def __del__(self):
-        """Clean up temporary directory on deletion."""
-        if hasattr(self, "temp_dir") and Path(self.temp_dir).exists():
-            shutil.rmtree(self.temp_dir)
-
-    def validate(self) -> None:
-        """
-        Validate the document against XSD schema and redlining rules.
-
-        Raises:
-            ValueError: If validation fails.
-        """
-        # Create validators with current state
-        schema_validator = DOCXSchemaValidator(
-            self.unpacked_path, self.original_docx, verbose=False
-        )
-        redlining_validator = RedliningValidator(
-            self.unpacked_path, self.original_docx, verbose=False
-        )
-
-        # Run validations
-        if not schema_validator.validate():
-            raise ValueError("Schema validation failed")
-        if not redlining_validator.validate():
-            raise ValueError("Redlining validation failed")
-
-    def save(self, destination=None, validate=True) -> None:
-        """
-        Save all modified XML files to disk and copy to destination directory.
-
-        This persists all changes made via add_comment() and reply_to_comment().
-
-        Args:
-            destination: Optional path to save to. If None, saves back to original directory.
-            validate: If True, validates document before saving (default: True).
-        """
-        # Only ensure comment relationships and content types if comment files exist
-        if self.comments_path.exists():
-            self._ensure_comment_relationships()
-            self._ensure_comment_content_types()
-
-        # Save all modified XML files in temp directory
-        for editor in self._editors.values():
-            editor.save()
-
-        # Validate by default
-        if validate:
-            self.validate()
-
-        # Copy contents from temp directory to destination (or original directory)
-        target_path = Path(destination) if destination else self.original_path
-        shutil.copytree(self.unpacked_path, target_path, dirs_exist_ok=True)
-
-    # ==================== Private: Initialization ====================
-
-    def _get_next_comment_id(self):
-        """Get the next available comment ID."""
-        if not self.comments_path.exists():
-            return 0
-
-        editor = self["word/comments.xml"]
-        max_id = -1
-        for comment_elem in editor.dom.getElementsByTagName("w:comment"):
-            comment_id = comment_elem.getAttribute("w:id")
-            if comment_id:
-                try:
-                    max_id = max(max_id, int(comment_id))
-                except ValueError:
-                    pass
-        return max_id + 1
-
-    def _load_existing_comments(self):
-        """Load existing comments from files to enable replies."""
-        if not self.comments_path.exists():
-            return {}
-
-        editor = self["word/comments.xml"]
-        existing = {}
-
-        for comment_elem in editor.dom.getElementsByTagName("w:comment"):
-            comment_id = comment_elem.getAttribute("w:id")
-            if not comment_id:
-                continue
-
-            # Find para_id from the w:p element within the comment
-            para_id = None
-            for p_elem in comment_elem.getElementsByTagName("w:p"):
-                para_id = p_elem.getAttribute("w14:paraId")
-                if para_id:
-                    break
-
-            if not para_id:
-                continue
-
-            existing[int(comment_id)] = {"para_id": para_id}
-
-        return existing
-
-    # ==================== Private: Setup Methods ====================
-
-    def _setup_tracking(self, track_revisions=False):
-        """Set up comment infrastructure in unpacked directory.
-
-        Args:
-            track_revisions: If True, enables track revisions in settings.xml
-        """
-        # Create or update word/people.xml
-        people_file = self.word_path / "people.xml"
-        self._update_people_xml(people_file)
-
-        # Update XML files
-        self._add_content_type_for_people(self.unpacked_path / "[Content_Types].xml")
-        self._add_relationship_for_people(
-            self.word_path / "_rels" / "document.xml.rels"
-        )
-
-        # Always add RSID to settings.xml, optionally enable trackRevisions
-        self._update_settings(
-            self.word_path / "settings.xml", track_revisions=track_revisions
-        )
-
-    def _update_people_xml(self, path):
-        """Create people.xml if it doesn't exist."""
-        if not path.exists():
-            # Copy from template
-            shutil.copy(TEMPLATE_DIR / "people.xml", path)
-
-    def _add_content_type_for_people(self, path):
-        """Add people.xml content type to [Content_Types].xml if not already present."""
-        editor = self["[Content_Types].xml"]
-
-        if self._has_override(editor, "/word/people.xml"):
-            return
-
-        # Add Override element
-        root = editor.dom.documentElement
-        override_xml = '<Override PartName="/word/people.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.people+xml"/>'
-        editor.append_to(root, override_xml)
-
-    def _add_relationship_for_people(self, path):
-        """Add people.xml relationship to document.xml.rels if not already present."""
-        editor = self["word/_rels/document.xml.rels"]
-
-        if self._has_relationship(editor, "people.xml"):
-            return
-
-        root = editor.dom.documentElement
-        root_tag = root.tagName  # type: ignore
-        prefix = root_tag.split(":")[0] + ":" if ":" in root_tag else ""
-        next_rid = editor.get_next_rid()
-
-        # Create the relationship entry
-        rel_xml = f'<{prefix}Relationship Id="{next_rid}" Type="http://schemas.microsoft.com/office/2011/relationships/people" Target="people.xml"/>'
-        editor.append_to(root, rel_xml)
-
-    def _update_settings(self, path, track_revisions=False):
-        """Add RSID and optionally enable track revisions in settings.xml.
-
-        Args:
-            path: Path to settings.xml
-            track_revisions: If True, adds trackRevisions element
-
-        Places elements per OOXML schema order:
-        - trackRevisions: early (before defaultTabStop)
-        - rsids: late (after compat)
-        """
-        editor = self["word/settings.xml"]
-        root = editor.get_node(tag="w:settings")
-        prefix = root.tagName.split(":")[0] if ":" in root.tagName else "w"
-
-        # Conditionally add trackRevisions if requested
-        if track_revisions:
-            track_revisions_exists = any(
-                elem.tagName == f"{prefix}:trackRevisions"
-                for elem in editor.dom.getElementsByTagName(f"{prefix}:trackRevisions")
-            )
-
-            if not track_revisions_exists:
-                track_rev_xml = f"<{prefix}:trackRevisions/>"
-                # Try to insert before documentProtection, defaultTabStop, or at start
-                inserted = False
-                for tag in [f"{prefix}:documentProtection", f"{prefix}:defaultTabStop"]:
-                    elements = editor.dom.getElementsByTagName(tag)
-                    if elements:
-                        editor.insert_before(elements[0], track_rev_xml)
-                        inserted = True
-                        break
-                if not inserted:
-                    # Insert as first child of settings
-                    if root.firstChild:
-                        editor.insert_before(root.firstChild, track_rev_xml)
-                    else:
-                        editor.append_to(root, track_rev_xml)
-
-        # Always check if rsids section exists
-        rsids_elements = editor.dom.getElementsByTagName(f"{prefix}:rsids")
-
-        if not rsids_elements:
-            # Add new rsids section
-            rsids_xml = f'''<{prefix}:rsids>
-  <{prefix}:rsidRoot {prefix}:val="{self.rsid}"/>
-  <{prefix}:rsid {prefix}:val="{self.rsid}"/>
-</{prefix}:rsids>'''
-
-            # Try to insert after compat, before clrSchemeMapping, or before closing tag
-            inserted = False
-            compat_elements = editor.dom.getElementsByTagName(f"{prefix}:compat")
-            if compat_elements:
-                editor.insert_after(compat_elements[0], rsids_xml)
-                inserted = True
-
-            if not inserted:
-                clr_elements = editor.dom.getElementsByTagName(
-                    f"{prefix}:clrSchemeMapping"
-                )
-                if clr_elements:
-                    editor.insert_before(clr_elements[0], rsids_xml)
-                    inserted = True
-
-            if not inserted:
-                editor.append_to(root, rsids_xml)
-        else:
-            # Check if this rsid already exists
-            rsids_elem = rsids_elements[0]
-            rsid_exists = any(
-                elem.getAttribute(f"{prefix}:val") == self.rsid
-                for elem in rsids_elem.getElementsByTagName(f"{prefix}:rsid")
-            )
-
-            if not rsid_exists:
-                rsid_xml = f'<{prefix}:rsid {prefix}:val="{self.rsid}"/>'
-                editor.append_to(rsids_elem, rsid_xml)
-
-    # ==================== Private: XML File Creation ====================
-
-    def _add_to_comments_xml(
-        self, comment_id, para_id, text, author, initials, timestamp
-    ):
-        """Add a single comment to comments.xml."""
-        if not self.comments_path.exists():
-            shutil.copy(TEMPLATE_DIR / "comments.xml", self.comments_path)
-
-        editor = self["word/comments.xml"]
-        root = editor.get_node(tag="w:comments")
-
-        escaped_text = (
-            text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
-        )
-        # Note: w:rsidR, w:rsidRDefault, w:rsidP on w:p, w:rsidR on w:r,
-        # and w:author, w:date, w:initials on w:comment are automatically added by DocxXMLEditor
-        comment_xml = f'''<w:comment w:id="{comment_id}">
-  <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>{escaped_text}</w:t></w:r>
-  </w:p>
-</w:comment>'''
-        editor.append_to(root, comment_xml)
-
-    def _add_to_comments_extended_xml(self, para_id, parent_para_id):
-        """Add a single comment to commentsExtended.xml."""
-        if not self.comments_extended_path.exists():
-            shutil.copy(
-                TEMPLATE_DIR / "commentsExtended.xml", self.comments_extended_path
-            )
-
-        editor = self["word/commentsExtended.xml"]
-        root = editor.get_node(tag="w15:commentsEx")
-
-        if parent_para_id:
-            xml = f'<w15:commentEx w15:paraId="{para_id}" w15:paraIdParent="{parent_para_id}" w15:done="0"/>'
-        else:
-            xml = f'<w15:commentEx w15:paraId="{para_id}" w15:done="0"/>'
-        editor.append_to(root, xml)
-
-    def _add_to_comments_ids_xml(self, para_id, durable_id):
-        """Add a single comment to commentsIds.xml."""
-        if not self.comments_ids_path.exists():
-            shutil.copy(TEMPLATE_DIR / "commentsIds.xml", self.comments_ids_path)
-
-        editor = self["word/commentsIds.xml"]
-        root = editor.get_node(tag="w16cid:commentsIds")
-
-        xml = f'<w16cid:commentId w16cid:paraId="{para_id}" w16cid:durableId="{durable_id}"/>'
-        editor.append_to(root, xml)
-
-    def _add_to_comments_extensible_xml(self, durable_id):
-        """Add a single comment to commentsExtensible.xml."""
-        if not self.comments_extensible_path.exists():
-            shutil.copy(
-                TEMPLATE_DIR / "commentsExtensible.xml", self.comments_extensible_path
-            )
-
-        editor = self["word/commentsExtensible.xml"]
-        root = editor.get_node(tag="w16cex:commentsExtensible")
-
-        xml = f'<w16cex:commentExtensible w16cex:durableId="{durable_id}"/>'
-        editor.append_to(root, xml)
-
-    # ==================== Private: XML Fragments ====================
-
-    def _comment_range_start_xml(self, comment_id):
-        """Generate XML for comment range start."""
-        return f'<w:commentRangeStart w:id="{comment_id}"/>'
-
-    def _comment_range_end_xml(self, comment_id):
-        """Generate XML for comment range end with reference run.
-
-        Note: w:rsidR is automatically added by DocxXMLEditor.
-        """
-        return f'''<w:commentRangeEnd w:id="{comment_id}"/>
-<w:r>
-  <w:rPr><w:rStyle w:val="CommentReference"/></w:rPr>
-  <w:commentReference w:id="{comment_id}"/>
-</w:r>'''
-
-    def _comment_ref_run_xml(self, comment_id):
-        """Generate XML for comment reference run.
-
-        Note: w:rsidR is automatically added by DocxXMLEditor.
-        """
-        return f'''<w:r>
-  <w:rPr><w:rStyle w:val="CommentReference"/></w:rPr>
-  <w:commentReference w:id="{comment_id}"/>
-</w:r>'''
-
-    # ==================== Private: Metadata Updates ====================
-
-    def _has_relationship(self, editor, target):
-        """Check if a relationship with given target exists."""
-        for rel_elem in editor.dom.getElementsByTagName("Relationship"):
-            if rel_elem.getAttribute("Target") == target:
-                return True
-        return False
-
-    def _has_override(self, editor, part_name):
-        """Check if an override with given part name exists."""
-        for override_elem in editor.dom.getElementsByTagName("Override"):
-            if override_elem.getAttribute("PartName") == part_name:
-                return True
-        return False
-
-    def _has_author(self, editor, author):
-        """Check if an author already exists in people.xml."""
-        for person_elem in editor.dom.getElementsByTagName("w15:person"):
-            if person_elem.getAttribute("w15:author") == author:
-                return True
-        return False
-
-    def _add_author_to_people(self, author):
-        """Add author to people.xml (called during initialization)."""
-        people_path = self.word_path / "people.xml"
-
-        # people.xml should already exist from _setup_tracking
-        if not people_path.exists():
-            raise ValueError("people.xml should exist after _setup_tracking")
-
-        editor = self["word/people.xml"]
-        root = editor.get_node(tag="w15:people")
-
-        # Check if author already exists
-        if self._has_author(editor, author):
-            return
-
-        # Add author with proper XML escaping to prevent injection
-        escaped_author = html.escape(author, quote=True)
-        person_xml = f'''<w15:person w15:author="{escaped_author}">
-  <w15:presenceInfo w15:providerId="None" w15:userId="{escaped_author}"/>
-</w15:person>'''
-        editor.append_to(root, person_xml)
-
-    def _ensure_comment_relationships(self):
-        """Ensure word/_rels/document.xml.rels has comment relationships."""
-        editor = self["word/_rels/document.xml.rels"]
-
-        if self._has_relationship(editor, "comments.xml"):
-            return
-
-        root = editor.dom.documentElement
-        root_tag = root.tagName  # type: ignore
-        prefix = root_tag.split(":")[0] + ":" if ":" in root_tag else ""
-        next_rid_num = int(editor.get_next_rid()[3:])
-
-        # Add relationship elements
-        rels = [
-            (
-                next_rid_num,
-                "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments",
-                "comments.xml",
-            ),
-            (
-                next_rid_num + 1,
-                "http://schemas.microsoft.com/office/2011/relationships/commentsExtended",
-                "commentsExtended.xml",
-            ),
-            (
-                next_rid_num + 2,
-                "http://schemas.microsoft.com/office/2016/09/relationships/commentsIds",
-                "commentsIds.xml",
-            ),
-            (
-                next_rid_num + 3,
-                "http://schemas.microsoft.com/office/2018/08/relationships/commentsExtensible",
-                "commentsExtensible.xml",
-            ),
-        ]
-
-        for rel_id, rel_type, target in rels:
-            rel_xml = f'<{prefix}Relationship Id="rId{rel_id}" Type="{rel_type}" Target="{target}"/>'
-            editor.append_to(root, rel_xml)
-
-    def _ensure_comment_content_types(self):
-        """Ensure [Content_Types].xml has comment content types."""
-        editor = self["[Content_Types].xml"]
-
-        if self._has_override(editor, "/word/comments.xml"):
-            return
-
-        root = editor.dom.documentElement
-
-        # Add Override elements
-        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",
-            ),
-        ]
-
-        for part_name, content_type in overrides:
-            override_xml = (
-                f'<Override PartName="{part_name}" ContentType="{content_type}"/>'
-            )
-            editor.append_to(root, override_xml)