@heylemon/lemonade 0.0.4 → 0.0.6

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

@@ -14,14 +14,6 @@ import defusedxml.minidom
 
 
 def merge_runs(input_dir: str) -> tuple[int, str]:
-    """Merge adjacent runs in document.xml.
-
-    Args:
-        input_dir: Path to unpacked DOCX directory
-
-    Returns:
-        (merge_count, message)
-    """
     doc_xml = Path(input_dir) / "word" / "document.xml"
 
     if not doc_xml.exists():
@@ -31,14 +23,11 @@ def merge_runs(input_dir: str) -> tuple[int, str]:
         dom = defusedxml.minidom.parseString(doc_xml.read_text(encoding="utf-8"))
         root = dom.documentElement
 
-        # Clean up elements that block merging
         _remove_elements(root, "proofErr")
         _strip_run_rsid_attrs(root)
 
-        # Find all containers that have runs
         containers = {run.parentNode for run in _find_elements(root, "r")}
 
-        # Merge runs in each container
         merge_count = 0
         for container in containers:
             merge_count += _merge_runs_in(container)
@@ -50,11 +39,9 @@ def merge_runs(input_dir: str) -> tuple[int, str]:
         return 0, f"Error: {e}"
 
 
-# --- Element helpers ---
 
 
 def _find_elements(root, tag: str) -> list:
-    """Find all elements matching tag name (with or without namespace)."""
     results = []
 
     def traverse(node):
@@ -70,7 +57,6 @@ def _find_elements(root, tag: str) -> list:
 
 
 def _get_child(parent, tag: str):
-    """Get first child element matching tag name."""
     for child in parent.childNodes:
         if child.nodeType == child.ELEMENT_NODE:
             name = child.localName or child.tagName
@@ -80,7 +66,6 @@ def _get_child(parent, tag: str):
 
 
 def _get_children(parent, tag: str) -> list:
-    """Get all direct child elements matching tag name."""
     results = []
     for child in parent.childNodes:
         if child.nodeType == child.ELEMENT_NODE:
@@ -91,7 +76,6 @@ def _get_children(parent, tag: str) -> list:
 
 
 def _is_adjacent(elem1, elem2) -> bool:
-    """Check if two elements are adjacent (only whitespace between them)."""
     node = elem1.nextSibling
     while node:
         if node == elem2:
@@ -104,34 +88,28 @@ def _is_adjacent(elem1, elem2) -> bool:
     return False
 
 
-# --- Cleanup functions ---
 
 
 def _remove_elements(root, tag: str):
-    """Remove all elements matching tag name."""
     for elem in _find_elements(root, tag):
         if elem.parentNode:
             elem.parentNode.removeChild(elem)
 
 
 def _strip_run_rsid_attrs(root):
-    """Remove rsid attributes from all run elements."""
     for run in _find_elements(root, "r"):
         for attr in list(run.attributes.values()):
             if "rsid" in attr.name.lower():
                 run.removeAttribute(attr.name)
 
 
-# --- Merge functions ---
 
 
 def _merge_runs_in(container) -> int:
-    """Merge adjacent runs with identical formatting in a container element."""
     merge_count = 0
     run = _first_child_run(container)
 
     while run:
-        # Absorb adjacent runs with same formatting
         while True:
             next_elem = _next_element_sibling(run)
             if next_elem and _is_run(next_elem) and _can_merge(run, next_elem):
@@ -148,7 +126,6 @@ def _merge_runs_in(container) -> int:
 
 
 def _first_child_run(container):
-    """Get the first run child of a container."""
     for child in container.childNodes:
         if child.nodeType == child.ELEMENT_NODE and _is_run(child):
             return child
@@ -156,7 +133,6 @@ def _first_child_run(container):
 
 
 def _next_element_sibling(node):
-    """Get the next element sibling, skipping text/whitespace nodes."""
     sibling = node.nextSibling
     while sibling:
         if sibling.nodeType == sibling.ELEMENT_NODE:
@@ -166,25 +142,21 @@ def _next_element_sibling(node):
 
 
 def _next_sibling_run(node):
-    """Get the next sibling that is a run element."""
     sibling = node.nextSibling
     while sibling:
         if sibling.nodeType == sibling.ELEMENT_NODE:
             if _is_run(sibling):
                 return sibling
-            # Skip non-run elements (bookmarks, etc.) but keep looking
         sibling = sibling.nextSibling
     return None
 
 
 def _is_run(node) -> bool:
-    """Check if node is a run element."""
     name = node.localName or node.tagName
     return name == "r" or name.endswith(":r")
 
 
 def _can_merge(run1, run2) -> bool:
-    """Check if two runs have identical formatting."""
     rpr1 = _get_child(run1, "rPr")
     rpr2 = _get_child(run2, "rPr")
 
@@ -192,11 +164,10 @@ def _can_merge(run1, run2) -> bool:
         return False
     if rpr1 is None:
         return True
-    return rpr1.toxml() == rpr2.toxml()  # type: ignore
+    return rpr1.toxml() == rpr2.toxml()  
 
 
 def _merge_run_content(target, source):
-    """Move content from source run to target run (excluding rPr)."""
     for child in list(source.childNodes):
         if child.nodeType == child.ELEMENT_NODE:
             name = child.localName or child.tagName
@@ -205,10 +176,8 @@ def _merge_run_content(target, source):
 
 
 def _consolidate_text(run):
-    """Merge adjacent <w:t> elements within a run."""
     t_elements = _get_children(run, "t")
 
-    # Work backwards to safely remove elements
     for i in range(len(t_elements) - 1, 0, -1):
         curr, prev = t_elements[i], t_elements[i - 1]
 
@@ -222,7 +191,6 @@ def _consolidate_text(run):
             else:
                 prev.appendChild(run.ownerDocument.createTextNode(merged))
 
-            # Preserve whitespace if needed
             if merged.startswith(" ") or merged.endswith(" "):
                 prev.setAttribute("xml:space", "preserve")
             elif prev.hasAttribute("xml:space"):

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

@@ -20,14 +20,6 @@ WORD_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
 
 
 def simplify_redlines(input_dir: str) -> tuple[int, str]:
-    """Merge adjacent tracked changes from the same author in document.xml.
-
-    Args:
-        input_dir: Path to unpacked DOCX directory
-
-    Returns:
-        (merge_count, message)
-    """
     doc_xml = Path(input_dir) / "word" / "document.xml"
 
     if not doc_xml.exists():
@@ -39,7 +31,6 @@ def simplify_redlines(input_dir: str) -> tuple[int, str]:
 
         merge_count = 0
 
-        # Find all paragraphs and table cells (containers for content)
         containers = _find_elements(root, "p") + _find_elements(root, "tc")
 
         for container in containers:
@@ -54,10 +45,8 @@ def simplify_redlines(input_dir: str) -> tuple[int, str]:
 
 
 def _merge_tracked_changes_in(container, tag: str) -> int:
-    """Merge adjacent w:ins or w:del elements from the same author."""
     merge_count = 0
 
-    # Get direct children that are tracked changes of this type
     tracked = [
         child
         for child in container.childNodes
@@ -67,7 +56,6 @@ def _merge_tracked_changes_in(container, tag: str) -> int:
     if len(tracked) < 2:
         return 0
 
-    # Process from front: merge next into current when possible
     i = 0
     while i < len(tracked) - 1:
         curr = tracked[i]
@@ -78,7 +66,6 @@ def _merge_tracked_changes_in(container, tag: str) -> int:
             container.removeChild(next_elem)
             tracked.pop(i + 1)
             merge_count += 1
-            # Don't increment i - try to merge more into curr
         else:
             i += 1
 
@@ -86,13 +73,11 @@ def _merge_tracked_changes_in(container, tag: str) -> int:
 
 
 def _is_element(node, tag: str) -> bool:
-    """Check if node matches the given tag name."""
     name = node.localName or node.tagName
     return name == tag or name.endswith(f":{tag}")
 
 
 def _get_author(elem) -> str:
-    """Get the author attribute from a tracked change element."""
     author = elem.getAttribute("w:author")
     if not author:
         for attr in elem.attributes.values():
@@ -102,12 +87,9 @@ def _get_author(elem) -> str:
 
 
 def _can_merge_tracked(elem1, elem2) -> bool:
-    """Check if two tracked change elements can be merged."""
-    # Must be same author
     if _get_author(elem1) != _get_author(elem2):
         return False
 
-    # Must be truly adjacent (only whitespace between them)
     node = elem1.nextSibling
     while node and node != elem2:
         if node.nodeType == node.ELEMENT_NODE:
@@ -120,7 +102,6 @@ def _can_merge_tracked(elem1, elem2) -> bool:
 
 
 def _merge_tracked_content(target, source):
-    """Move all children from source tracked change to target."""
     while source.firstChild:
         child = source.firstChild
         source.removeChild(child)
@@ -128,7 +109,6 @@ def _merge_tracked_content(target, source):
 
 
 def _find_elements(root, tag: str) -> list:
-    """Find all elements matching tag name (with or without namespace)."""
     results = []
 
     def traverse(node):
@@ -144,11 +124,6 @@ def _find_elements(root, tag: str) -> list:
 
 
 def get_tracked_change_authors(doc_xml_path: Path) -> dict[str, int]:
-    """Get authors and their tracked change counts from a document.xml file.
-
-    Returns:
-        Dict mapping author name to count of tracked changes (w:ins + w:del)
-    """
     if not doc_xml_path.exists():
         return {}
 
@@ -172,7 +147,6 @@ def get_tracked_change_authors(doc_xml_path: Path) -> dict[str, int]:
 
 
 def _get_authors_from_docx(docx_path: Path) -> dict[str, int]:
-    """Get authors and counts from a packed DOCX file."""
     try:
         with zipfile.ZipFile(docx_path, "r") as zf:
             if "word/document.xml" not in zf.namelist():
@@ -196,22 +170,6 @@ def _get_authors_from_docx(docx_path: Path) -> dict[str, int]:
 
 
 def infer_author(modified_dir: Path, original_docx: Path, default: str = "Claude") -> str:
-    """Infer the author to validate by finding who added tracked changes.
-
-    Compares tracked change counts between modified and original documents.
-    Returns the author who added new tracked changes.
-
-    Args:
-        modified_dir: Path to unpacked DOCX directory
-        original_docx: Path to original DOCX file
-        default: Default author if no new changes found
-
-    Returns:
-        Author name to use for validation
-
-    Raises:
-        ValueError: If multiple authors added new changes (ambiguous)
-    """
     modified_xml = modified_dir / "word" / "document.xml"
     modified_authors = get_tracked_change_authors(modified_xml)
 
@@ -220,7 +178,6 @@ def infer_author(modified_dir: Path, original_docx: Path, default: str = "Claude
 
     original_authors = _get_authors_from_docx(original_docx)
 
-    # Calculate new changes per author (modified count - original count)
     new_changes: dict[str, int] = {}
     for author, count in modified_authors.items():
         original_count = original_authors.get(author, 0)

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

@@ -1,4 +1,3 @@
-#!/usr/bin/env python3
 """Pack a directory into a DOCX, PPTX, or XLSX file.
 
 Validates with auto-repair, condenses XML formatting, and creates the Office file.
@@ -29,18 +28,6 @@ def pack(
     validate: bool = True,
     infer_author_func=None,
 ) -> tuple[None, str]:
-    """Pack a directory into an Office file (DOCX, PPTX, or XLSX).
-
-    Args:
-        input_directory: Path to unpacked Office document directory
-        output_file: Path to output Office file
-        original_file: Path to original file for validation comparison
-        validate: If True, run validation with auto-repair before packing
-        infer_author_func: Optional function to infer author for redlining validation
-
-    Returns:
-        (None, message) - message indicates success or failure
-    """
     input_dir = Path(input_directory)
     output_path = Path(output_file)
     suffix = output_path.suffix.lower()
@@ -51,7 +38,6 @@ def pack(
     if suffix not in {".docx", ".pptx", ".xlsx"}:
         return None, f"Error: {output_file} must be a .docx, .pptx, or .xlsx file"
 
-    # Validate with auto-repair if requested and original file provided
     if validate and original_file:
         original_path = Path(original_file)
         if original_path.exists():
@@ -63,17 +49,14 @@ def pack(
             if not success:
                 return None, f"Error: Validation failed for {input_dir}"
 
-    # Work in temporary directory to avoid modifying original
     with tempfile.TemporaryDirectory() as temp_dir:
         temp_content_dir = Path(temp_dir) / "content"
         shutil.copytree(input_dir, temp_content_dir)
 
-        # Process XML files to remove pretty-printing whitespace
         for pattern in ["*.xml", "*.rels"]:
             for xml_file in temp_content_dir.rglob(pattern):
                 _condense_xml(xml_file)
 
-        # Create final Office file as zip archive
         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("*"):
@@ -89,16 +72,10 @@ def _run_validation(
     suffix: str,
     infer_author_func=None,
 ) -> tuple[bool, str | None]:
-    """Run validation with auto-repair.
-
-    Returns:
-        (success, output) - success is True if all validations pass
-    """
     output_lines = []
     validators = []
 
     if suffix == ".docx":
-        # Infer author for redlining validation
         author = "Claude"
         if infer_author_func:
             try:
@@ -112,17 +89,14 @@ def _run_validation(
         ]
     elif suffix == ".pptx":
         validators = [PPTXSchemaValidator(unpacked_dir, original_file)]
-    # xlsx has no schema validator yet
 
     if not validators:
         return True, None
 
-    # Run auto-repair
     total_repairs = sum(v.repair() for v in validators)
     if total_repairs:
         output_lines.append(f"Auto-repaired {total_repairs} issue(s)")
 
-    # Run validation
     success = all(v.validate() for v in validators)
 
     if success:
@@ -132,18 +106,14 @@ def _run_validation(
 
 
 def _condense_xml(xml_file: Path) -> None:
-    """Strip unnecessary whitespace and remove comments from XML."""
     try:
         with open(xml_file, encoding="utf-8") as f:
             dom = defusedxml.minidom.parse(f)
 
-        # Process each element to remove whitespace and comments
         for element in dom.getElementsByTagName("*"):
-            # Skip text elements (w:t, a:t, etc.) - preserve their content
             if element.tagName.endswith(":t"):
                 continue
 
-            # Remove whitespace-only text nodes and comment nodes
             for child in list(element.childNodes):
                 if (
                     child.nodeType == child.TEXT_NODE