@bcelep/capint 0.4.2 → 0.6.5

package/skills/docx/scripts/internals/preprocessing/revision_merger.py

@@ -0,0 +1,193 @@
+"""Merge adjacent tracked-change wrappers from the same author.
+
+When multiple sequential edits occur, Word creates separate <w:ins> or <w:del>
+elements for each edit even when the author is identical. This produces verbose
+XML that is harder to read and edit. This module collapses them into single
+wrappers where safe to do so.
+
+Merge criteria:
+- Same element type (ins+ins or del+del only)
+- Same author attribute (timestamps may differ)
+- No intervening element nodes between them
+"""
+
+import xml.etree.ElementTree as ET
+import zipfile
+from pathlib import Path
+
+import defusedxml.minidom
+
+WML_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+
+
+def merge_adjacent_revisions(workspace: str) -> tuple[int, str]:
+    main_doc = Path(workspace) / "word" / "document.xml"
+    if not main_doc.exists():
+        return 0, f"Error: {main_doc} not found"
+
+    try:
+        dom = defusedxml.minidom.parseString(main_doc.read_text(encoding="utf-8"))
+        root = dom.documentElement
+
+        total = 0
+        for container in _scan_for(root, "p") + _scan_for(root, "tc"):
+            total += _collapse_adjacent(container, "ins")
+            total += _collapse_adjacent(container, "del")
+
+        main_doc.write_bytes(dom.toxml(encoding="UTF-8"))
+        return total, f"Merged {total} adjacent revision blocks"
+    except Exception as exc:
+        return 0, f"Error: {exc}"
+
+
+def _collapse_adjacent(parent, tag_name: str) -> int:
+    candidates = [
+        ch for ch in parent.childNodes
+        if ch.nodeType == ch.ELEMENT_NODE and _matches_tag(ch, tag_name)
+    ]
+
+    if len(candidates) < 2:
+        return 0
+
+    collapsed = 0
+    idx = 0
+    while idx < len(candidates) - 1:
+        current = candidates[idx]
+        following = candidates[idx + 1]
+
+        if _safe_to_merge(current, following):
+            _transfer_children(current, following)
+            parent.removeChild(following)
+            candidates.pop(idx + 1)
+            collapsed += 1
+        else:
+            idx += 1
+
+    return collapsed
+
+
+def _matches_tag(node, local_name: str) -> bool:
+    tag = node.localName or node.tagName
+    return tag == local_name or tag.endswith(f":{local_name}")
+
+
+def _extract_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 _safe_to_merge(elem_a, elem_b) -> bool:
+    if _extract_author(elem_a) != _extract_author(elem_b):
+        return False
+
+    cursor = elem_a.nextSibling
+    while cursor and cursor != elem_b:
+        if cursor.nodeType == cursor.ELEMENT_NODE:
+            return False
+        if cursor.nodeType == cursor.TEXT_NODE and cursor.data.strip():
+            return False
+        cursor = cursor.nextSibling
+
+    return True
+
+
+def _transfer_children(target, source):
+    while source.firstChild:
+        child = source.firstChild
+        source.removeChild(child)
+        target.appendChild(child)
+
+
+def _scan_for(root, local_name: str) -> list:
+    found = []
+
+    def walk(node):
+        if node.nodeType == node.ELEMENT_NODE:
+            tag = node.localName or node.tagName
+            if tag == local_name or tag.endswith(f":{local_name}"):
+                found.append(node)
+            for ch in node.childNodes:
+                walk(ch)
+
+    walk(root)
+    return found
+
+
+def discover_revision_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 {}
+
+    ns = {"w": WML_NS}
+    author_key = f"{{{WML_NS}}}author"
+    tally: dict[str, int] = {}
+
+    for tag in ("ins", "del"):
+        for elem in root.findall(f".//w:{tag}", ns):
+            who = elem.get(author_key)
+            if who:
+                tally[who] = tally.get(who, 0) + 1
+
+    return tally
+
+
+def _extract_authors_from_archive(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 fh:
+                tree = ET.parse(fh)
+                root = tree.getroot()
+                ns = {"w": WML_NS}
+                author_key = f"{{{WML_NS}}}author"
+                tally: dict[str, int] = {}
+                for tag in ("ins", "del"):
+                    for elem in root.findall(f".//w:{tag}", ns):
+                        who = elem.get(author_key)
+                        if who:
+                            tally[who] = tally.get(who, 0) + 1
+                return tally
+    except (zipfile.BadZipFile, ET.ParseError):
+        return {}
+
+
+def detect_editing_author(
+    modified_dir: Path,
+    original_archive: Path,
+    fallback: str = "Verdent",
+) -> str:
+    modified_xml = modified_dir / "word" / "document.xml"
+    current_authors = discover_revision_authors(modified_xml)
+
+    if not current_authors:
+        return fallback
+
+    baseline_authors = _extract_authors_from_archive(original_archive)
+
+    new_contributions: dict[str, int] = {}
+    for author, count in current_authors.items():
+        baseline = baseline_authors.get(author, 0)
+        delta = count - baseline
+        if delta > 0:
+            new_contributions[author] = delta
+
+    if not new_contributions:
+        return fallback
+
+    if len(new_contributions) == 1:
+        return next(iter(new_contributions))
+
+    raise ValueError(
+        f"Multiple authors contributed new changes: {new_contributions}. "
+        "Cannot determine the primary editing author."
+    )

package/skills/docx/scripts/internals/preprocessing/run_consolidator.py

@@ -0,0 +1,179 @@
+"""Consolidate adjacent text runs that share identical formatting.
+
+When Word saves a document, it often splits logically continuous text into
+many tiny <w:r> elements due to revision tracking, spell-check, or cursor
+position history. This module recombines them for cleaner XML editing.
+
+Also strips rsid attributes (revision session IDs) and proofErr markers
+that fragment runs without affecting visible output.
+"""
+
+from pathlib import Path
+
+import defusedxml.minidom
+
+
+def consolidate_adjacent_runs(workspace: str) -> tuple[int, str]:
+    main_doc = Path(workspace) / "word" / "document.xml"
+    if not main_doc.exists():
+        return 0, f"Error: {main_doc} not found"
+
+    try:
+        dom = defusedxml.minidom.parseString(main_doc.read_text(encoding="utf-8"))
+        root = dom.documentElement
+
+        _purge_nodes_by_tag(root, "proofErr")
+        _clear_session_markers(root)
+
+        parents = {r.parentNode for r in _collect_by_tag(root, "r")}
+        total = sum(_merge_within(container) for container in parents)
+
+        main_doc.write_bytes(dom.toxml(encoding="UTF-8"))
+        return total, f"Consolidated {total} runs"
+    except Exception as exc:
+        return 0, f"Error: {exc}"
+
+
+def _collect_by_tag(root, local_name: str) -> list:
+    found = []
+
+    def walk(node):
+        if node.nodeType == node.ELEMENT_NODE:
+            tag = node.localName or node.tagName
+            if tag == local_name or tag.endswith(f":{local_name}"):
+                found.append(node)
+            for ch in node.childNodes:
+                walk(ch)
+
+    walk(root)
+    return found
+
+
+def _tag_matches(node, local_name: str) -> bool:
+    tag = node.localName or node.tagName
+    return tag == local_name or tag.endswith(f":{local_name}")
+
+
+def _get_first_child(parent, local_name: str):
+    for ch in parent.childNodes:
+        if ch.nodeType == ch.ELEMENT_NODE and _tag_matches(ch, local_name):
+            return ch
+    return None
+
+
+def _get_all_children(parent, local_name: str) -> list:
+    return [
+        ch for ch in parent.childNodes
+        if ch.nodeType == ch.ELEMENT_NODE and _tag_matches(ch, local_name)
+    ]
+
+
+def _purge_nodes_by_tag(root, local_name: str):
+    for node in _collect_by_tag(root, local_name):
+        if node.parentNode:
+            node.parentNode.removeChild(node)
+
+
+def _clear_session_markers(root):
+    for run in _collect_by_tag(root, "r"):
+        for attr in list(run.attributes.values()):
+            if "rsid" in attr.name.lower():
+                run.removeAttribute(attr.name)
+
+
+def _next_element(node):
+    sibling = node.nextSibling
+    while sibling:
+        if sibling.nodeType == sibling.ELEMENT_NODE:
+            return sibling
+        sibling = sibling.nextSibling
+    return None
+
+
+def _next_run_sibling(node):
+    sibling = node.nextSibling
+    while sibling:
+        if sibling.nodeType == sibling.ELEMENT_NODE:
+            if _tag_matches(sibling, "r"):
+                return sibling
+            return None
+        if sibling.nodeType == sibling.TEXT_NODE and sibling.data.strip():
+            return None
+        sibling = sibling.nextSibling
+    return None
+
+
+def _formatting_matches(run_a, run_b) -> bool:
+    props_a = _get_first_child(run_a, "rPr")
+    props_b = _get_first_child(run_b, "rPr")
+
+    if (props_a is None) != (props_b is None):
+        return False
+    if props_a is None:
+        return True
+    return props_a.toxml() == props_b.toxml()
+
+
+def _absorb_content(target, source):
+    for child in list(source.childNodes):
+        if child.nodeType == child.ELEMENT_NODE:
+            tag = child.localName or child.tagName
+            if not (tag == "rPr" or tag.endswith(":rPr")):
+                target.appendChild(child)
+
+
+def _unify_text_nodes(run):
+    text_elems = _get_all_children(run, "t")
+    for i in range(len(text_elems) - 1, 0, -1):
+        curr = text_elems[i]
+        prev = text_elems[i - 1]
+
+        prev_val = prev.firstChild.data if prev.firstChild else ""
+        curr_val = curr.firstChild.data if curr.firstChild else ""
+        combined = prev_val + curr_val
+
+        if prev.firstChild:
+            prev.firstChild.data = combined
+        else:
+            prev.appendChild(run.ownerDocument.createTextNode(combined))
+
+        if combined.startswith(" ") or combined.endswith(" "):
+            prev.setAttribute("xml:space", "preserve")
+        elif prev.hasAttribute("xml:space"):
+            prev.removeAttribute("xml:space")
+
+        run.removeChild(curr)
+
+
+def _merge_within(container) -> int:
+    merged = 0
+    run = None
+    for ch in container.childNodes:
+        if ch.nodeType == ch.ELEMENT_NODE and _tag_matches(ch, "r"):
+            run = ch
+            break
+
+    if not run:
+        return 0
+
+    while run:
+        while True:
+            neighbor = _next_element(run)
+            if neighbor and _tag_matches(neighbor, "r") and _formatting_matches(run, neighbor):
+                _absorb_content(run, neighbor)
+                container.removeChild(neighbor)
+                merged += 1
+            else:
+                break
+
+        _unify_text_nodes(run)
+
+        nxt = run.nextSibling
+        run = None
+        while nxt:
+            if nxt.nodeType == nxt.ELEMENT_NODE and _tag_matches(nxt, "r"):
+                run = nxt
+                break
+            nxt = nxt.nextSibling
+
+    return merged

package/skills/docx/scripts/internals/runtime/converter.py

@@ -0,0 +1,184 @@
+"""Format conversion utilities using LibreOffice.
+
+Handles .doc -> .docx conversion and .docx -> .pdf export,
+with automatic detection and workaround for sandboxed environments
+where AF_UNIX sockets are blocked.
+"""
+
+import os
+import socket
+import subprocess
+import tempfile
+from pathlib import Path
+
+
+def get_office_env() -> dict:
+    env = os.environ.copy()
+    env["SAL_USE_VCLPLUGIN"] = "svp"
+
+    if _unix_sockets_blocked():
+        shim = _build_socket_shim()
+        env["LD_PRELOAD"] = str(shim)
+
+    return env
+
+
+def invoke_office(cli_args: list[str], **kwargs) -> subprocess.CompletedProcess:
+    env = get_office_env()
+    return subprocess.run(["soffice"] + cli_args, env=env, **kwargs)
+
+
+def transform_format(source: str, target_format: str = "docx") -> Path:
+    src = Path(source)
+    if not src.exists():
+        raise FileNotFoundError(f"{source} not found")
+
+    out_dir = src.parent
+    result = invoke_office(
+        ["--headless", "--convert-to", target_format,
+         "--outdir", str(out_dir), str(src)],
+        capture_output=True,
+        timeout=60,
+    )
+
+    expected = out_dir / f"{src.stem}.{target_format}"
+    if expected.exists():
+        print(f"Converted {source} -> {expected}")
+        return expected
+
+    raise RuntimeError(
+        f"Conversion failed: {result.stderr.decode() if result.stderr else 'unknown error'}"
+    )
+
+
+_SHIM_BINARY = Path(tempfile.gettempdir()) / "office_socket_bridge.so"
+
+
+def _unix_sockets_blocked() -> bool:
+    try:
+        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        sock.close()
+        return False
+    except OSError:
+        return True
+
+
+def _build_socket_shim() -> Path:
+    if _SHIM_BINARY.exists():
+        return _SHIM_BINARY
+
+    shim_src = Path(tempfile.gettempdir()) / "office_socket_bridge.c"
+    shim_src.write_text(_BRIDGE_SOURCE_CODE)
+    subprocess.run(
+        ["gcc", "-shared", "-fPIC", "-o", str(_SHIM_BINARY), str(shim_src), "-ldl"],
+        check=True,
+        capture_output=True,
+    )
+    shim_src.unlink()
+    return _SHIM_BINARY
+
+
+_BRIDGE_SOURCE_CODE = r"""
+#define _GNU_SOURCE
+#include <dlfcn.h>
+#include <errno.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+static int (*orig_socket)(int, int, int);
+static int (*orig_socketpair)(int, int, int, int[2]);
+static int (*orig_listen)(int, int);
+static int (*orig_accept)(int, struct sockaddr *, socklen_t *);
+static int (*orig_close)(int);
+static int (*orig_read)(int, void *, size_t);
+
+static int bridged[1024];
+static int paired[1024];
+static int signal_rd[1024];
+static int signal_wr[1024];
+static int server_fd = -1;
+
+__attribute__((constructor))
+static void setup(void) {
+    orig_socket     = dlsym(RTLD_NEXT, "socket");
+    orig_socketpair = dlsym(RTLD_NEXT, "socketpair");
+    orig_listen     = dlsym(RTLD_NEXT, "listen");
+    orig_accept     = dlsym(RTLD_NEXT, "accept");
+    orig_close      = dlsym(RTLD_NEXT, "close");
+    orig_read       = dlsym(RTLD_NEXT, "read");
+    for (int i = 0; i < 1024; i++) {
+        paired[i] = -1;
+        signal_rd[i] = -1;
+        signal_wr[i] = -1;
+    }
+}
+
+int socket(int domain, int type, int protocol) {
+    if (domain == AF_UNIX) {
+        int fd = orig_socket(domain, type, protocol);
+        if (fd >= 0) return fd;
+        int sv[2];
+        if (orig_socketpair(domain, type, protocol, sv) == 0) {
+            if (sv[0] >= 0 && sv[0] < 1024) {
+                bridged[sv[0]] = 1;
+                paired[sv[0]] = sv[1];
+                int pp[2];
+                if (pipe(pp) == 0) {
+                    signal_rd[sv[0]] = pp[0];
+                    signal_wr[sv[0]] = pp[1];
+                }
+            }
+            return sv[0];
+        }
+        errno = EPERM;
+        return -1;
+    }
+    return orig_socket(domain, type, protocol);
+}
+
+int listen(int sockfd, int backlog) {
+    if (sockfd >= 0 && sockfd < 1024 && bridged[sockfd]) {
+        server_fd = sockfd;
+        return 0;
+    }
+    return orig_listen(sockfd, backlog);
+}
+
+int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen) {
+    if (sockfd >= 0 && sockfd < 1024 && bridged[sockfd]) {
+        if (signal_rd[sockfd] >= 0) {
+            char b;
+            orig_read(signal_rd[sockfd], &b, 1);
+        }
+        errno = ECONNABORTED;
+        return -1;
+    }
+    return orig_accept(sockfd, addr, addrlen);
+}
+
+int close(int fd) {
+    if (fd >= 0 && fd < 1024 && bridged[fd]) {
+        int was_server = (fd == server_fd);
+        bridged[fd] = 0;
+        if (signal_wr[fd] >= 0) {
+            char c = 0;
+            write(signal_wr[fd], &c, 1);
+            orig_close(signal_wr[fd]);
+            signal_wr[fd] = -1;
+        }
+        if (signal_rd[fd] >= 0) { orig_close(signal_rd[fd]); signal_rd[fd] = -1; }
+        if (paired[fd] >= 0) { orig_close(paired[fd]); paired[fd] = -1; }
+        if (was_server) _exit(0);
+    }
+    return orig_close(fd);
+}
+"""
+
+
+if __name__ == "__main__":
+    import sys
+    result = invoke_office(sys.argv[1:])
+    sys.exit(result.returncode)

package/skills/docx/scripts/internals/runtime/renderer.py

@@ -0,0 +1,60 @@
+"""Render Word document pages as JPEG images for visual inspection.
+
+Uses LibreOffice for PDF conversion and Poppler for rasterization.
+"""
+
+import subprocess
+import tempfile
+from pathlib import Path
+
+from .converter import get_office_env
+
+
+def pages_to_images(
+    doc_path: str,
+    page_range: str | None = None,
+    resolution: int = 150,
+    output_dir: str | None = None,
+) -> list[Path]:
+    source = Path(doc_path)
+    if not source.exists():
+        raise FileNotFoundError(f"{doc_path} not found")
+
+    dest = Path(output_dir) if output_dir else source.parent
+    dest.mkdir(parents=True, exist_ok=True)
+
+    with tempfile.TemporaryDirectory() as staging:
+        staging_path = Path(staging)
+
+        subprocess.run(
+            ["soffice", "--headless", "--convert-to", "pdf",
+             "--outdir", str(staging_path), str(source)],
+            env=get_office_env(),
+            capture_output=True,
+            timeout=60,
+            check=False,
+        )
+
+        pdf_candidates = list(staging_path.glob("*.pdf"))
+        if not pdf_candidates:
+            raise RuntimeError("PDF conversion failed — no output produced")
+
+        pdf_file = pdf_candidates[0]
+
+        poppler_args = [
+            "pdftoppm", "-jpeg", "-r", str(resolution),
+        ]
+        if page_range:
+            parts = page_range.split("-")
+            poppler_args.extend(["-f", parts[0]])
+            if len(parts) > 1:
+                poppler_args.extend(["-l", parts[1]])
+
+        poppler_args.extend([str(pdf_file), str(dest / "page")])
+
+        subprocess.run(poppler_args, capture_output=True, timeout=120, check=True)
+
+    outputs = sorted(dest.glob("page-*.jpg"))
+    if outputs:
+        print(f"Rendered {len(outputs)} page(s) to {dest}")
+    return outputs