takomi 2.0.4

package/assets/.agent/skills/docx/scripts/comment.py

@@ -0,0 +1,318 @@
+"""Add comments to DOCX documents.
+
+Usage:
+    python comment.py unpacked/ 0 "Comment text"
+    python comment.py unpacked/ 1 "Reply text" --parent 0
+
+Text should be pre-escaped XML (e.g., & for &, ’ for smart quotes).
+
+After running, add markers to document.xml:
+  <w:commentRangeStart w:id="0"/>
+  ... commented content ...
+  <w:commentRangeEnd w:id="0"/>
+  <w:r><w:rPr><w:rStyle w:val="CommentReference"/></w:rPr><w:commentReference w:id="0"/></w:r>
+"""
+
+import argparse
+import random
+import shutil
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+import defusedxml.minidom
+
+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>{text}</w:t>
+    </w:r>
+  </w:p>
+</w:comment>"""
+
+COMMENT_MARKER_TEMPLATE = """
+Add to 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 (markers must be 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>"""
+
+
+def _generate_hex_id() -> str:
+    return f"{random.randint(0, 0x7FFFFFFE):08X}"
+
+
+SMART_QUOTE_ENTITIES = {
+    "\u201c": "&#x201C;",  
+    "\u201d": "&#x201D;",  
+    "\u2018": "&#x2018;",  
+    "\u2019": "&#x2019;",  
+}
+
+
+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 _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"))
+    for rel in dom.getElementsByTagName("Relationship"):
+        if rel.getAttribute("Target") == target:
+            return True
+    return False
+
+
+def _has_content_type(ct_path: Path, part_name: str) -> bool:
+    dom = defusedxml.minidom.parseString(ct_path.read_text(encoding="utf-8"))
+    for override in dom.getElementsByTagName("Override"):
+        if override.getAttribute("PartName") == part_name:
+            return True
+    return False
+
+
+def _ensure_comment_relationships(unpacked_dir: Path) -> None:
+    rels_path = unpacked_dir / "word" / "_rels" / "document.xml.rels"
+    if not rels_path.exists():
+        return
+
+    if _has_relationship(rels_path, "comments.xml"):
+        return  
+
+    dom = defusedxml.minidom.parseString(rels_path.read_text(encoding="utf-8"))
+    root = dom.documentElement
+    next_rid = _get_next_rid(rels_path)
+
+    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",
+        ),
+    ]
+
+    for rel_type, target in rels:
+        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
+
+    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
+
+    if _has_content_type(ct_path, "/word/comments.xml"):
+        return  
+
+    dom = defusedxml.minidom.parseString(ct_path.read_text(encoding="utf-8"))
+    root = dom.documentElement
+
+    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 = dom.createElement("Override")
+        override.setAttribute("PartName", part_name)
+        override.setAttribute("ContentType", content_type)
+        root.appendChild(override)  
+
+    ct_path.write_bytes(dom.toxml(encoding="UTF-8"))
+
+
+def add_comment(
+    unpacked_dir: str,
+    comment_id: int,
+    text: str,
+    author: str = "Claude",
+    initials: str = "C",
+    parent_id: int | None = None,
+) -> tuple[str, str]:
+    word = Path(unpacked_dir) / "word"
+    if not word.exists():
+        return "", f"Error: {word} not found"
+
+    para_id, durable_id = _generate_hex_id(), _generate_hex_id()
+    ts = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    comments = word / "comments.xml"
+    first_comment = not comments.exists()
+    if first_comment:
+        shutil.copy(TEMPLATE_DIR / "comments.xml", comments)
+        _ensure_comment_relationships(Path(unpacked_dir))
+        _ensure_comment_content_types(Path(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_id is not None:
+        parent_para = _find_para_id(comments, parent_id)
+        if not parent_para:
+            return "", f"Error: Parent comment {parent_id} not found"
+        _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 para_id, f"Added {action} {comment_id} (para_id={para_id})"
+
+
+if __name__ == "__main__":
+    p = argparse.ArgumentParser(description="Add comments to DOCX documents")
+    p.add_argument("unpacked_dir", help="Unpacked DOCX directory")
+    p.add_argument("comment_id", type=int, help="Comment ID (must be unique)")
+    p.add_argument("text", help="Comment text")
+    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 (for replies)")
+    args = p.parse_args()
+
+    para_id, msg = add_comment(
+        args.unpacked_dir,
+        args.comment_id,
+        args.text,
+        args.author,
+        args.initials,
+        args.parent,
+    )
+    print(msg)
+    if "Error" in msg:
+        sys.exit(1)
+    cid = args.comment_id
+    if args.parent is not None:
+        print(REPLY_MARKER_TEMPLATE.format(pid=args.parent, cid=cid))
+    else:
+        print(COMMENT_MARKER_TEMPLATE.format(cid=cid))

package/assets/.agent/skills/docx/scripts/office/helpers/merge_runs.py

@@ -0,0 +1,199 @@
+"""Merge adjacent runs with identical formatting in DOCX.
+
+Merges adjacent <w:r> elements that have identical <w:rPr> properties.
+Works on runs in paragraphs and inside tracked changes (<w:ins>, <w:del>).
+
+Also:
+- Removes rsid attributes from runs (revision metadata that doesn't affect rendering)
+- Removes proofErr elements (spell/grammar markers that block merging)
+"""
+
+from pathlib import Path
+
+import defusedxml.minidom
+
+
+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
+
+        _remove_elements(root, "proofErr")
+        _strip_run_rsid_attrs(root)
+
+        containers = {run.parentNode for run in _find_elements(root, "r")}
+
+        merge_count = 0
+        for container in containers:
+            merge_count += _merge_runs_in(container)
+
+        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 _find_elements(root, tag: str) -> list:
+    results = []
+
+    def traverse(node):
+        if node.nodeType == node.ELEMENT_NODE:
+            name = node.localName or node.tagName
+            if name == tag or name.endswith(f":{tag}"):
+                results.append(node)
+            for child in node.childNodes:
+                traverse(child)
+
+    traverse(root)
+    return results
+
+
+def _get_child(parent, tag: str):
+    for child in parent.childNodes:
+        if child.nodeType == child.ELEMENT_NODE:
+            name = child.localName or child.tagName
+            if name == tag or name.endswith(f":{tag}"):
+                return child
+    return None
+
+
+def _get_children(parent, tag: str) -> list:
+    results = []
+    for child in parent.childNodes:
+        if child.nodeType == child.ELEMENT_NODE:
+            name = child.localName or child.tagName
+            if name == tag or name.endswith(f":{tag}"):
+                results.append(child)
+    return results
+
+
+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():
+            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_run_rsid_attrs(root):
+    for run in _find_elements(root, "r"):
+        for attr in list(run.attributes.values()):
+            if "rsid" in attr.name.lower():
+                run.removeAttribute(attr.name)
+
+
+
+
+def _merge_runs_in(container) -> int:
+    merge_count = 0
+    run = _first_child_run(container)
+
+    while run:
+        while True:
+            next_elem = _next_element_sibling(run)
+            if next_elem and _is_run(next_elem) 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)
+
+    return merge_count
+
+
+def _first_child_run(container):
+    for child in container.childNodes:
+        if child.nodeType == child.ELEMENT_NODE and _is_run(child):
+            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):
+    sibling = node.nextSibling
+    while sibling:
+        if sibling.nodeType == sibling.ELEMENT_NODE:
+            if _is_run(sibling):
+                return sibling
+        sibling = sibling.nextSibling
+    return None
+
+
+def _is_run(node) -> bool:
+    name = node.localName or node.tagName
+    return name == "r" or name.endswith(":r")
+
+
+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 _consolidate_text(run):
+    t_elements = _get_children(run, "t")
+
+    for i in range(len(t_elements) - 1, 0, -1):
+        curr, prev = t_elements[i], t_elements[i - 1]
+
+        if _is_adjacent(prev, curr):
+            prev_text = prev.firstChild.data if prev.firstChild else ""
+            curr_text = curr.firstChild.data if curr.firstChild else ""
+            merged = prev_text + curr_text
+
+            if prev.firstChild:
+                prev.firstChild.data = merged
+            else:
+                prev.appendChild(run.ownerDocument.createTextNode(merged))
+
+            if merged.startswith(" ") or merged.endswith(" "):
+                prev.setAttribute("xml:space", "preserve")
+            elif prev.hasAttribute("xml:space"):
+                prev.removeAttribute("xml:space")
+
+            run.removeChild(curr)