@xopcai/xopc 0.0.102 → 0.0.104

package/skills/documents/docx/scripts/accept_changes.py

@@ -1,135 +0,0 @@
-"""Accept all tracked changes in a DOCX file using LibreOffice.
-
-Requires LibreOffice (soffice) to be installed.
-"""
-
-import argparse
-import logging
-import shutil
-import subprocess
-from pathlib import Path
-
-from office.soffice import get_soffice_env
-
-logger = logging.getLogger(__name__)
-
-LIBREOFFICE_PROFILE = "/tmp/libreoffice_docx_profile"
-MACRO_DIR = f"{LIBREOFFICE_PROFILE}/user/basic/Standard"
-
-ACCEPT_CHANGES_MACRO = """<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE script:module PUBLIC "-//OpenOffice.org//DTD OfficeDocument 1.0//EN" "module.dtd">
-<script:module xmlns:script="http://openoffice.org/2000/script" script:name="Module1" script:language="StarBasic">
-    Sub AcceptAllTrackedChanges()
-        Dim document As Object
-        Dim dispatcher As Object
-
-        document = ThisComponent.CurrentController.Frame
-        dispatcher = createUnoService("com.sun.star.frame.DispatchHelper")
-
-        dispatcher.executeDispatch(document, ".uno:AcceptAllTrackedChanges", "", 0, Array())
-        ThisComponent.store()
-        ThisComponent.close(True)
-    End Sub
-</script:module>"""
-
-
-def accept_changes(
-    input_file: str,
-    output_file: str,
-) -> tuple[None, str]:
-    input_path = Path(input_file)
-    output_path = Path(output_file)
-
-    if not input_path.exists():
-        return None, f"Error: Input file not found: {input_file}"
-
-    if not input_path.suffix.lower() == ".docx":
-        return None, f"Error: Input file is not a DOCX file: {input_file}"
-
-    try:
-        output_path.parent.mkdir(parents=True, exist_ok=True)
-        shutil.copy2(input_path, output_path)
-    except Exception as e:
-        return None, f"Error: Failed to copy input file to output location: {e}"
-
-    if not _setup_libreoffice_macro():
-        return None, "Error: Failed to setup LibreOffice macro"
-
-    cmd = [
-        "soffice",
-        "--headless",
-        f"-env:UserInstallation=file://{LIBREOFFICE_PROFILE}",
-        "--norestore",
-        "vnd.sun.star.script:Standard.Module1.AcceptAllTrackedChanges?language=Basic&location=application",
-        str(output_path.absolute()),
-    ]
-
-    try:
-        result = subprocess.run(
-            cmd,
-            capture_output=True,
-            text=True,
-            timeout=30,
-            check=False,
-            env=get_soffice_env(),
-        )
-    except subprocess.TimeoutExpired:
-        return (
-            None,
-            f"Successfully accepted all tracked changes: {input_file} -> {output_file}",
-        )
-
-    if result.returncode != 0:
-        return None, f"Error: LibreOffice failed: {result.stderr}"
-
-    return (
-        None,
-        f"Successfully accepted all tracked changes: {input_file} -> {output_file}",
-    )
-
-
-def _setup_libreoffice_macro() -> bool:
-    macro_dir = Path(MACRO_DIR)
-    macro_file = macro_dir / "Module1.xba"
-
-    if macro_file.exists() and "AcceptAllTrackedChanges" in macro_file.read_text():
-        return True
-
-    if not macro_dir.exists():
-        subprocess.run(
-            [
-                "soffice",
-                "--headless",
-                f"-env:UserInstallation=file://{LIBREOFFICE_PROFILE}",
-                "--terminate_after_init",
-            ],
-            capture_output=True,
-            timeout=10,
-            check=False,
-            env=get_soffice_env(),
-        )
-        macro_dir.mkdir(parents=True, exist_ok=True)
-
-    try:
-        macro_file.write_text(ACCEPT_CHANGES_MACRO)
-        return True
-    except Exception as e:
-        logger.warning(f"Failed to setup LibreOffice macro: {e}")
-        return False
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(
-        description="Accept all tracked changes in a DOCX file"
-    )
-    parser.add_argument("input_file", help="Input DOCX file with tracked changes")
-    parser.add_argument(
-        "output_file", help="Output DOCX file (clean, no tracked changes)"
-    )
-    args = parser.parse_args()
-
-    _, message = accept_changes(args.input_file, args.output_file)
-    print(message)
-
-    if "Error" in message:
-        raise SystemExit(1)

package/skills/documents/docx/scripts/comment.py

@@ -1,318 +0,0 @@
-"""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/skills/documents/docx/scripts/office/helpers/merge_runs.py

@@ -1,199 +0,0 @@
-"""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)