wormclaude 1.0.119 → 1.0.121

package/skills/xlsx/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)

package/skills/xlsx/scripts/office/helpers/simplify_redlines.py

@@ -1,197 +0,0 @@
-"""Simplify tracked changes by merging adjacent w:ins or w:del elements.
-
-Merges adjacent <w:ins> elements from the same author into a single element.
-Same for <w:del> elements. This makes heavily-redlined documents easier to
-work with by reducing the number of tracked change wrappers.
-
-Rules:
-- Only merges w:ins with w:ins, w:del with w:del (same element type)
-- Only merges if same author (ignores timestamp differences)
-- Only merges if truly adjacent (only whitespace between them)
-"""
-
-import xml.etree.ElementTree as ET
-import zipfile
-from pathlib import Path
-
-import defusedxml.minidom
-
-WORD_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
-
-
-def simplify_redlines(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
-
-        merge_count = 0
-
-        containers = _find_elements(root, "p") + _find_elements(root, "tc")
-
-        for container in containers:
-            merge_count += _merge_tracked_changes_in(container, "ins")
-            merge_count += _merge_tracked_changes_in(container, "del")
-
-        doc_xml.write_bytes(dom.toxml(encoding="UTF-8"))
-        return merge_count, f"Simplified {merge_count} tracked changes"
-
-    except Exception as e:
-        return 0, f"Error: {e}"
-
-
-def _merge_tracked_changes_in(container, tag: str) -> int:
-    merge_count = 0
-
-    tracked = [
-        child
-        for child in container.childNodes
-        if child.nodeType == child.ELEMENT_NODE and _is_element(child, tag)
-    ]
-
-    if len(tracked) < 2:
-        return 0
-
-    i = 0
-    while i < len(tracked) - 1:
-        curr = tracked[i]
-        next_elem = tracked[i + 1]
-
-        if _can_merge_tracked(curr, next_elem):
-            _merge_tracked_content(curr, next_elem)
-            container.removeChild(next_elem)
-            tracked.pop(i + 1)
-            merge_count += 1
-        else:
-            i += 1
-
-    return merge_count
-
-
-def _is_element(node, tag: str) -> bool:
-    name = node.localName or node.tagName
-    return name == tag or name.endswith(f":{tag}")
-
-
-def _get_author(elem) -> str:
-    author = elem.getAttribute("w:author")
-    if not author:
-        for attr in elem.attributes.values():
-            if attr.localName == "author" or attr.name.endswith(":author"):
-                return attr.value
-    return author
-
-
-def _can_merge_tracked(elem1, elem2) -> bool:
-    if _get_author(elem1) != _get_author(elem2):
-        return False
-
-    node = elem1.nextSibling
-    while node and node != elem2:
-        if node.nodeType == node.ELEMENT_NODE:
-            return False
-        if node.nodeType == node.TEXT_NODE and node.data.strip():
-            return False
-        node = node.nextSibling
-
-    return True
-
-
-def _merge_tracked_content(target, source):
-    while source.firstChild:
-        child = source.firstChild
-        source.removeChild(child)
-        target.appendChild(child)
-
-
-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_tracked_change_authors(doc_xml_path: Path) -> dict[str, int]:
-    if not doc_xml_path.exists():
-        return {}
-
-    try:
-        tree = ET.parse(doc_xml_path)
-        root = tree.getroot()
-    except ET.ParseError:
-        return {}
-
-    namespaces = {"w": WORD_NS}
-    author_attr = f"{{{WORD_NS}}}author"
-
-    authors: dict[str, int] = {}
-    for tag in ["ins", "del"]:
-        for elem in root.findall(f".//w:{tag}", namespaces):
-            author = elem.get(author_attr)
-            if author:
-                authors[author] = authors.get(author, 0) + 1
-
-    return authors
-
-
-def _get_authors_from_docx(docx_path: Path) -> dict[str, int]:
-    try:
-        with zipfile.ZipFile(docx_path, "r") as zf:
-            if "word/document.xml" not in zf.namelist():
-                return {}
-            with zf.open("word/document.xml") as f:
-                tree = ET.parse(f)
-                root = tree.getroot()
-
-                namespaces = {"w": WORD_NS}
-                author_attr = f"{{{WORD_NS}}}author"
-
-                authors: dict[str, int] = {}
-                for tag in ["ins", "del"]:
-                    for elem in root.findall(f".//w:{tag}", namespaces):
-                        author = elem.get(author_attr)
-                        if author:
-                            authors[author] = authors.get(author, 0) + 1
-                return authors
-    except (zipfile.BadZipFile, ET.ParseError):
-        return {}
-
-
-def infer_author(modified_dir: Path, original_docx: Path, default: str = "WormClaude") -> str:
-    modified_xml = modified_dir / "word" / "document.xml"
-    modified_authors = get_tracked_change_authors(modified_xml)
-
-    if not modified_authors:
-        return default
-
-    original_authors = _get_authors_from_docx(original_docx)
-
-    new_changes: dict[str, int] = {}
-    for author, count in modified_authors.items():
-        original_count = original_authors.get(author, 0)
-        diff = count - original_count
-        if diff > 0:
-            new_changes[author] = diff
-
-    if not new_changes:
-        return default
-
-    if len(new_changes) == 1:
-        return next(iter(new_changes))
-
-    raise ValueError(
-        f"Multiple authors added new changes: {new_changes}. "
-        "Cannot infer which author to validate."
-    )

package/skills/xlsx/scripts/office/pack.py

@@ -1,159 +0,0 @@
-"""Pack a directory into a DOCX, PPTX, or XLSX file.
-
-Validates with auto-repair, condenses XML formatting, and creates the Office file.
-
-Usage:
-    python pack.py <input_directory> <output_file> [--original <file>] [--validate true|false]
-
-Examples:
-    python pack.py unpacked/ output.docx --original input.docx
-    python pack.py unpacked/ output.pptx --validate false
-"""
-
-import argparse
-import sys
-import shutil
-import tempfile
-import zipfile
-from pathlib import Path
-
-import defusedxml.minidom
-
-from validators import DOCXSchemaValidator, PPTXSchemaValidator, RedliningValidator
-
-def pack(
-    input_directory: str,
-    output_file: str,
-    original_file: str | None = None,
-    validate: bool = True,
-    infer_author_func=None,
-) -> tuple[None, str]:
-    input_dir = Path(input_directory)
-    output_path = Path(output_file)
-    suffix = output_path.suffix.lower()
-
-    if not input_dir.is_dir():
-        return None, f"Error: {input_dir} is not a directory"
-
-    if suffix not in {".docx", ".pptx", ".xlsx"}:
-        return None, f"Error: {output_file} must be a .docx, .pptx, or .xlsx file"
-
-    if validate and original_file:
-        original_path = Path(original_file)
-        if original_path.exists():
-            success, output = _run_validation(
-                input_dir, original_path, suffix, infer_author_func
-            )
-            if output:
-                print(output)
-            if not success:
-                return None, f"Error: Validation failed for {input_dir}"
-
-    with tempfile.TemporaryDirectory() as temp_dir:
-        temp_content_dir = Path(temp_dir) / "content"
-        shutil.copytree(input_dir, temp_content_dir)
-
-        for pattern in ["*.xml", "*.rels"]:
-            for xml_file in temp_content_dir.rglob(pattern):
-                _condense_xml(xml_file)
-
-        output_path.parent.mkdir(parents=True, exist_ok=True)
-        with zipfile.ZipFile(output_path, "w", zipfile.ZIP_DEFLATED) as zf:
-            for f in temp_content_dir.rglob("*"):
-                if f.is_file():
-                    zf.write(f, f.relative_to(temp_content_dir))
-
-    return None, f"Successfully packed {input_dir} to {output_file}"
-
-
-def _run_validation(
-    unpacked_dir: Path,
-    original_file: Path,
-    suffix: str,
-    infer_author_func=None,
-) -> tuple[bool, str | None]:
-    output_lines = []
-    validators = []
-
-    if suffix == ".docx":
-        author = "Wormclaude"
-        if infer_author_func:
-            try:
-                author = infer_author_func(unpacked_dir, original_file)
-            except ValueError as e:
-                print(f"Warning: {e} Using default author 'WormClaude'.", file=sys.stderr)
-
-        validators = [
-            DOCXSchemaValidator(unpacked_dir, original_file),
-            RedliningValidator(unpacked_dir, original_file, author=author),
-        ]
-    elif suffix == ".pptx":
-        validators = [PPTXSchemaValidator(unpacked_dir, original_file)]
-
-    if not validators:
-        return True, None
-
-    total_repairs = sum(v.repair() for v in validators)
-    if total_repairs:
-        output_lines.append(f"Auto-repaired {total_repairs} issue(s)")
-
-    success = all(v.validate() for v in validators)
-
-    if success:
-        output_lines.append("All validations PASSED!")
-
-    return success, "\n".join(output_lines) if output_lines else None
-
-
-def _condense_xml(xml_file: Path) -> None:
-    try:
-        with open(xml_file, encoding="utf-8") as f:
-            dom = defusedxml.minidom.parse(f)
-
-        for element in dom.getElementsByTagName("*"):
-            if element.tagName.endswith(":t"):
-                continue
-
-            for child in list(element.childNodes):
-                if (
-                    child.nodeType == child.TEXT_NODE
-                    and child.nodeValue
-                    and child.nodeValue.strip() == ""
-                ) or child.nodeType == child.COMMENT_NODE:
-                    element.removeChild(child)
-
-        xml_file.write_bytes(dom.toxml(encoding="UTF-8"))
-    except Exception as e:
-        print(f"ERROR: Failed to parse {xml_file.name}: {e}", file=sys.stderr)
-        raise
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(
-        description="Pack a directory into a DOCX, PPTX, or XLSX file"
-    )
-    parser.add_argument("input_directory", help="Unpacked Office document directory")
-    parser.add_argument("output_file", help="Output Office file (.docx/.pptx/.xlsx)")
-    parser.add_argument(
-        "--original",
-        help="Original file for validation comparison",
-    )
-    parser.add_argument(
-        "--validate",
-        type=lambda x: x.lower() == "true",
-        default=True,
-        metavar="true|false",
-        help="Run validation with auto-repair (default: true)",
-    )
-    args = parser.parse_args()
-
-    _, message = pack(
-        args.input_directory,
-        args.output_file,
-        original_file=args.original,
-        validate=args.validate,
-    )
-    print(message)
-
-    if "Error" in message:
-        sys.exit(1)