@panda-agent/panda-cli 0.1.28 → 0.1.30

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

@@ -0,0 +1,190 @@
+"""Coalesce adjacent ``<w:r>`` elements that share identical formatting.
+
+Operates on paragraphs *and* tracked-change containers (``<w:ins>``,
+``<w:del>``).  Additionally strips RSID attributes from runs and removes
+``proofErr`` spell/grammar markers that would otherwise prevent merging.
+"""
+
+import pathlib
+
+import defusedxml.minidom
+
+
+# ── DOM traversal utilities ──────────────────────────────────────────────────
+
+def _collect_by_tag(root, tag: str) -> list:
+    """Depth-first search for every element whose local name matches *tag*."""
+    hits: list = []
+    def _walk(nd):
+        if nd.nodeType == nd.ELEMENT_NODE:
+            lname = nd.localName or nd.tagName
+            if lname == tag or lname.endswith(":%s" % tag):
+                hits.append(nd)
+            for ch in nd.childNodes:
+                _walk(ch)
+    _walk(root)
+    return hits
+
+
+def _child_by_tag(parent, tag: str):
+    """Return the first direct child element matching *tag*, or ``None``."""
+    for ch in parent.childNodes:
+        if ch.nodeType != ch.ELEMENT_NODE:
+            continue
+        lname = ch.localName or ch.tagName
+        if lname == tag or lname.endswith(":%s" % tag):
+            return ch
+    return None
+
+
+def _children_by_tag(parent, tag: str) -> list:
+    return [
+        ch for ch in parent.childNodes
+        if ch.nodeType == ch.ELEMENT_NODE
+        and ((ch.localName or ch.tagName) == tag
+             or (ch.localName or ch.tagName).endswith(":%s" % tag))
+    ]
+
+
+def _directly_adjacent(a, b) -> bool:
+    """True when *a* and *b* are separated only by insignificant whitespace."""
+    cur = a.nextSibling
+    while cur is not None:
+        if cur is b:
+            return True
+        if cur.nodeType == cur.ELEMENT_NODE:
+            return False
+        if cur.nodeType == cur.TEXT_NODE and cur.data.strip():
+            return False
+        cur = cur.nextSibling
+    return False
+
+
+def _tag_matches_run(nd) -> bool:
+    lname = nd.localName or nd.tagName
+    return lname == "r" or lname.endswith(":r")
+
+
+# ── Cleanup passes ───────────────────────────────────────────────────────────
+
+def _purge_elements(root, tag: str) -> None:
+    for el in _collect_by_tag(root, tag):
+        if el.parentNode:
+            el.parentNode.removeChild(el)
+
+
+def _erase_rsid_attributes(root) -> None:
+    for rn in _collect_by_tag(root, "r"):
+        doomed = [a for a in rn.attributes.values() if "rsid" in a.name.lower()]
+        for attr in doomed:
+            rn.removeAttribute(attr.name)
+
+
+# ── Core merging logic ───────────────────────────────────────────────────────
+
+def _formatting_equal(r1, r2) -> bool:
+    rpr_a = _child_by_tag(r1, "rPr")
+    rpr_b = _child_by_tag(r2, "rPr")
+    if (rpr_a is None) != (rpr_b is None):
+        return False
+    return True if rpr_a is None else rpr_a.toxml() == rpr_b.toxml()
+
+
+def _absorb_content(dest, src) -> None:
+    """Move non-rPr children of *src* into *dest*."""
+    for ch in list(src.childNodes):
+        if ch.nodeType != ch.ELEMENT_NODE:
+            continue
+        lname = ch.localName or ch.tagName
+        if lname == "rPr" or lname.endswith(":rPr"):
+            continue
+        dest.appendChild(ch)
+
+
+def _next_elem(nd):
+    sib = nd.nextSibling
+    while sib is not None:
+        if sib.nodeType == sib.ELEMENT_NODE:
+            return sib
+        sib = sib.nextSibling
+    return None
+
+
+def _next_run_sibling(nd):
+    sib = nd.nextSibling
+    while sib is not None:
+        if sib.nodeType == sib.ELEMENT_NODE and _tag_matches_run(sib):
+            return sib
+        sib = sib.nextSibling
+    return None
+
+
+def _first_run_child(container):
+    for ch in container.childNodes:
+        if ch.nodeType == ch.ELEMENT_NODE and _tag_matches_run(ch):
+            return ch
+    return None
+
+
+def _squash_text_nodes(run) -> None:
+    """Combine consecutive ``<w:t>`` (or ``<w:delText>``) nodes inside *run*."""
+    t_nodes = _children_by_tag(run, "t")
+    idx = len(t_nodes) - 1
+    while idx > 0:
+        cur, prev = t_nodes[idx], t_nodes[idx - 1]
+        if _directly_adjacent(prev, cur):
+            txt_prev = prev.firstChild.data if prev.firstChild else ""
+            txt_cur = cur.firstChild.data if cur.firstChild else ""
+            combined = txt_prev + txt_cur
+            if prev.firstChild:
+                prev.firstChild.data = combined
+            else:
+                prev.appendChild(run.ownerDocument.createTextNode(combined))
+            if combined[0:1] == " " or combined[-1:] == " ":
+                prev.setAttribute("xml:space", "preserve")
+            elif prev.hasAttribute("xml:space"):
+                prev.removeAttribute("xml:space")
+            run.removeChild(cur)
+        idx -= 1
+
+
+def _merge_within(container) -> int:
+    """Merge consecutive runs with equal formatting inside *container*."""
+    total = 0
+    rn = _first_run_child(container)
+    while rn is not None:
+        while True:
+            nxt = _next_elem(rn)
+            if nxt is not None and _tag_matches_run(nxt) and _formatting_equal(rn, nxt):
+                _absorb_content(rn, nxt)
+                container.removeChild(nxt)
+                total += 1
+            else:
+                break
+        _squash_text_nodes(rn)
+        rn = _next_run_sibling(rn)
+    return total
+
+
+# ── Public entry point ───────────────────────────────────────────────────────
+
+def merge_runs(input_dir: str) -> tuple[int, str]:
+    """Coalesce adjacent identically-formatted runs in ``document.xml``."""
+    doc_path = pathlib.Path(input_dir) / "word" / "document.xml"
+    if not doc_path.exists():
+        return 0, "Error: %s not found" % doc_path
+
+    try:
+        dom = defusedxml.minidom.parseString(doc_path.read_text(encoding="utf-8"))
+        top = dom.documentElement
+
+        _purge_elements(top, "proofErr")
+        _erase_rsid_attributes(top)
+
+        parents = {rn.parentNode for rn in _collect_by_tag(top, "r")}
+        merged = sum(_merge_within(p) for p in parents)
+
+        doc_path.write_bytes(dom.toxml(encoding="UTF-8"))
+        return merged, "Merged %d runs" % merged
+    except Exception as exc:
+        return 0, "Error: %s" % exc

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

@@ -0,0 +1,185 @@
+"""Collapse consecutive tracked-change wrappers from the same reviewer.
+
+Adjacent ``<w:ins>`` blocks by the same author are folded into one element;
+likewise for ``<w:del>``.  This dramatically reduces clutter in documents
+with heavy revision history.
+
+Constraints:
+  * Only same-type merges: ``ins`` with ``ins``, ``del`` with ``del``.
+  * Author must match (timestamps are ignored).
+  * Elements must be truly adjacent — only insignificant whitespace allowed
+    between them.
+"""
+
+import pathlib
+import xml.etree.ElementTree as ET
+import zipfile
+
+import defusedxml.minidom
+
+_WML_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+
+
+# ── DOM helpers (minidom) ────────────────────────────────────────────────────
+
+def _scan_elements(root, tag: str) -> list:
+    found: list = []
+    def _recurse(nd):
+        if nd.nodeType == nd.ELEMENT_NODE:
+            lname = nd.localName or nd.tagName
+            if lname == tag or lname.endswith(":%s" % tag):
+                found.append(nd)
+            for ch in nd.childNodes:
+                _recurse(ch)
+    _recurse(root)
+    return found
+
+
+def _tag_match(nd, tag: str) -> bool:
+    lname = nd.localName or nd.tagName
+    return lname == tag or lname.endswith(":%s" % tag)
+
+
+def _extract_author(elem) -> str:
+    val = elem.getAttribute("w:author")
+    if val:
+        return val
+    for attr in elem.attributes.values():
+        if attr.localName == "author" or attr.name.endswith(":author"):
+            return attr.value
+    return ""
+
+
+def _only_whitespace_between(first, second) -> bool:
+    cur = first.nextSibling
+    while cur is not None and cur is not second:
+        if cur.nodeType == cur.ELEMENT_NODE:
+            return False
+        if cur.nodeType == cur.TEXT_NODE and cur.data.strip():
+            return False
+        cur = cur.nextSibling
+    return True
+
+
+def _transplant_children(dest, src) -> None:
+    while src.firstChild:
+        node = src.firstChild
+        src.removeChild(node)
+        dest.appendChild(node)
+
+
+def _fold_tracked_in(container, tag: str) -> int:
+    candidates = [
+        ch for ch in container.childNodes
+        if ch.nodeType == ch.ELEMENT_NODE and _tag_match(ch, tag)
+    ]
+    if len(candidates) < 2:
+        return 0
+
+    count = 0
+    pos = 0
+    while pos < len(candidates) - 1:
+        left, right = candidates[pos], candidates[pos + 1]
+        if _extract_author(left) == _extract_author(right) and _only_whitespace_between(left, right):
+            _transplant_children(left, right)
+            container.removeChild(right)
+            candidates.pop(pos + 1)
+            count += 1
+        else:
+            pos += 1
+    return count
+
+
+# ── Public API (minidom-based) ───────────────────────────────────────────────
+
+def simplify_redlines(input_dir: str) -> tuple[int, str]:
+    """Merge adjacent same-author tracked changes in ``document.xml``."""
+    doc_path = pathlib.Path(input_dir) / "word" / "document.xml"
+    if not doc_path.exists():
+        return 0, "Error: %s not found" % doc_path
+
+    try:
+        dom = defusedxml.minidom.parseString(doc_path.read_text(encoding="utf-8"))
+        top = dom.documentElement
+
+        buckets = _scan_elements(top, "p") + _scan_elements(top, "tc")
+        total = 0
+        for bkt in buckets:
+            total += _fold_tracked_in(bkt, "ins")
+            total += _fold_tracked_in(bkt, "del")
+
+        dom_bytes = dom.toxml(encoding="UTF-8")
+        doc_path.write_bytes(dom_bytes)
+        return total, "Simplified %d tracked changes" % total
+    except Exception as exc:
+        return 0, "Error: %s" % exc
+
+
+# ── ElementTree-based author analysis ────────────────────────────────────────
+
+def get_tracked_change_authors(doc_xml_path: pathlib.Path) -> dict[str, int]:
+    """Return ``{author: change_count}`` from an unpacked ``document.xml``."""
+    if not doc_xml_path.exists():
+        return {}
+    try:
+        tree = ET.parse(doc_xml_path)
+    except ET.ParseError:
+        return {}
+
+    ns = {"w": _WML_NS}
+    attr_key = "{%s}author" % _WML_NS
+    tally: dict[str, int] = {}
+    for kind in ("ins", "del"):
+        for el in tree.getroot().findall(".//w:%s" % kind, ns):
+            who = el.get(attr_key)
+            if who:
+                tally[who] = tally.get(who, 0) + 1
+    return tally
+
+
+def _authors_inside_docx(docx_path: pathlib.Path) -> dict[str, int]:
+    """Read author stats directly from a zipped ``.docx``."""
+    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 fh:
+                tree = ET.parse(fh)
+
+                ns = {"w": _WML_NS}
+                attr_key = "{%s}author" % _WML_NS
+                tally: dict[str, int] = {}
+                for kind in ("ins", "del"):
+                    for el in tree.getroot().findall(".//w:%s" % kind, ns):
+                        who = el.get(attr_key)
+                        if who:
+                            tally[who] = tally.get(who, 0) + 1
+                return tally
+    except (zipfile.BadZipFile, ET.ParseError):
+        return {}
+
+
+def infer_author(modified_dir: pathlib.Path, original_docx: pathlib.Path, default: str = "Claude") -> str:
+    """Guess which single author introduced new tracked changes."""
+    mod_xml = modified_dir / "word" / "document.xml"
+    mod_authors = get_tracked_change_authors(mod_xml)
+    if not mod_authors:
+        return default
+
+    orig_authors = _authors_inside_docx(original_docx)
+
+    delta: dict[str, int] = {}
+    for who, n in mod_authors.items():
+        diff = n - orig_authors.get(who, 0)
+        if diff > 0:
+            delta[who] = diff
+
+    if not delta:
+        return default
+    if len(delta) == 1:
+        return next(iter(delta))
+
+    raise ValueError(
+        "Multiple authors added new changes: %s. "
+        "Cannot infer which author to validate." % delta
+    )

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

@@ -0,0 +1,167 @@
+"""Reassemble an unpacked Office directory into a DOCX / PPTX / XLSX archive.
+
+The tool validates with automatic repair, strips cosmetic whitespace from XML,
+and produces the final ZIP-based file.
+
+Invocation::
+
+    python pack.py <src_dir> <dest_file> [--original <file>] [--validate true|false]
+
+Samples::
+
+    python pack.py unpacked/ output.docx --original input.docx
+    python pack.py unpacked/ output.pptx --validate false
+"""
+
+import argparse
+import shutil
+import sys
+import tempfile
+import zipfile
+import pathlib
+
+import defusedxml.minidom
+
+from validators import DOCXSchemaValidator, PPTXSchemaValidator, RedliningValidator
+
+
+_ALLOWED_EXTENSIONS = {".docx", ".pptx", ".xlsx"}
+
+
+def _strip_xml_formatting(fp: pathlib.Path) -> None:
+    """Collapse pretty-printed XML back to a compact single-line form."""
+    try:
+        with open(fp, encoding="utf-8") as fh:
+            parsed = defusedxml.minidom.parse(fh)
+
+        for el in parsed.getElementsByTagName("*"):
+            if el.tagName.endswith(":t"):
+                continue
+            children_to_drop = [
+                ch for ch in list(el.childNodes)
+                if (ch.nodeType == ch.TEXT_NODE and ch.nodeValue and ch.nodeValue.strip() == "")
+                or ch.nodeType == ch.COMMENT_NODE
+            ]
+            for ch in children_to_drop:
+                el.removeChild(ch)
+
+        fp.write_bytes(parsed.toxml(encoding="UTF-8"))
+    except Exception as err:
+        print("ERROR: Failed to parse {}: {}".format(fp.name, err), file=sys.stderr)
+        raise
+
+
+def _execute_validators(
+    src_dir: pathlib.Path,
+    orig: pathlib.Path,
+    ext: str,
+    author_fn=None,
+) -> tuple[bool, str | None]:
+    """Run the appropriate validator chain and return (ok, log_text)."""
+    log_parts: list[str] = []
+    checkers: list = []
+
+    if ext == ".docx":
+        writer = "Claude"
+        if author_fn:
+            try:
+                writer = author_fn(src_dir, orig)
+            except ValueError as ve:
+                print("Warning: {} Using default author 'Claude'.".format(ve), file=sys.stderr)
+        checkers = [
+            DOCXSchemaValidator(src_dir, orig),
+            RedliningValidator(src_dir, orig, author=writer),
+        ]
+    elif ext == ".pptx":
+        checkers = [PPTXSchemaValidator(src_dir, orig)]
+
+    if not checkers:
+        return True, None
+
+    fixed = sum(c.repair() for c in checkers)
+    if fixed:
+        log_parts.append("Auto-repaired {} issue(s)".format(fixed))
+
+    ok = all(c.validate() for c in checkers)
+    if ok:
+        log_parts.append("All validations PASSED!")
+
+    return ok, "\n".join(log_parts) if log_parts else None
+
+
+def pack(
+    input_directory: str,
+    output_file: str,
+    original_file: str | None = None,
+    validate: bool = True,
+    infer_author_func=None,
+) -> tuple[None, str]:
+    """Pack *input_directory* into *output_file* (Office ZIP archive)."""
+    src = pathlib.Path(input_directory)
+    dest = pathlib.Path(output_file)
+    ext = dest.suffix.lower()
+
+    if not src.is_dir():
+        return None, "Error: {} is not a directory".format(src)
+
+    if ext not in _ALLOWED_EXTENSIONS:
+        return None, "Error: {} must be a .docx, .pptx, or .xlsx file".format(output_file)
+
+    if validate and original_file:
+        orig_p = pathlib.Path(original_file)
+        if orig_p.exists():
+            ok, report = _execute_validators(src, orig_p, ext, infer_author_func)
+            if report:
+                print(report)
+            if not ok:
+                return None, "Error: Validation failed for {}".format(src)
+
+    with tempfile.TemporaryDirectory() as scratch:
+        staging = pathlib.Path(scratch) / "content"
+        shutil.copytree(src, staging)
+
+        xml_globs = ("*.xml", "*.rels")
+        for g in xml_globs:
+            for xf in staging.rglob(g):
+                _strip_xml_formatting(xf)
+
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        with zipfile.ZipFile(dest, "w", zipfile.ZIP_DEFLATED) as zf:
+            for item in staging.rglob("*"):
+                if item.is_file():
+                    zf.write(item, item.relative_to(staging))
+
+    return None, "Successfully packed {} to {}".format(src, output_file)
+
+
+# ── CLI ──────────────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser(
+        description="Pack a directory into a DOCX, PPTX, or XLSX file"
+    )
+    ap.add_argument("input_directory", help="Unpacked Office document directory")
+    ap.add_argument("output_file", help="Output Office file (.docx/.pptx/.xlsx)")
+    ap.add_argument(
+        "--original",
+        help="Original file for validation comparison",
+    )
+    ap.add_argument(
+        "--validate",
+        type=lambda v: v.lower() == "true",
+        default=True,
+        metavar="true|false",
+        help="Run validation with auto-repair (default: true)",
+    )
+    cli = ap.parse_args()
+
+    _, message = pack(
+        cli.input_directory,
+        cli.output_file,
+        original_file=cli.original,
+        validate=cli.validate,
+    )
+    print(message)
+
+    if "Error" in message:
+        sys.exit(1)