@panda-agent/panda-cli 0.1.28 → 0.1.30

package/skills/docx/scripts/office/schemas/microsoft/wml-cex-2018.xsd

@@ -0,0 +1,20 @@
+ <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:s="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" xmlns:w16="http://schemas.microsoft.com/office/word/2018/wordml" elementFormDefault="qualified" attributeFormDefault="qualified" blockDefault="#all" xmlns="http://schemas.microsoft.com/office/word/2018/wordml/cex" targetNamespace="http://schemas.microsoft.com/office/word/2018/wordml/cex">
+   <xsd:import id="w16" namespace="http://schemas.microsoft.com/office/word/2018/wordml" schemaLocation="wml-2018.xsd"/>
+   <xsd:import id="w" namespace="http://schemas.openxmlformats.org/wordprocessingml/2006/main" schemaLocation="../ISO-IEC29500-4_2016/wml.xsd"/>
+   <xsd:import id="s" namespace="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" schemaLocation="../ISO-IEC29500-4_2016/shared-commonSimpleTypes.xsd"/>
+   <xsd:complexType name="CT_CommentsExtensible">
+     <xsd:sequence>
+       <xsd:element name="commentExtensible" type="CT_CommentExtensible" minOccurs="0" maxOccurs="unbounded"/>
+       <xsd:element name="extLst" type="w16:CT_ExtensionList" minOccurs="0" maxOccurs="1"/>
+     </xsd:sequence>
+   </xsd:complexType>
+   <xsd:complexType name="CT_CommentExtensible">
+     <xsd:sequence>
+       <xsd:element name="extLst" type="w16:CT_ExtensionList" minOccurs="0" maxOccurs="1"/>
+     </xsd:sequence>
+     <xsd:attribute name="durableId" type="w:ST_LongHexNumber" use="required"/>
+     <xsd:attribute name="dateUtc" type="w:ST_DateTime" use="optional"/>
+     <xsd:attribute name="intelligentPlaceholder" type="s:ST_OnOff" use="optional"/>
+   </xsd:complexType>
+   <xsd:element name="commentsExtensible" type="CT_CommentsExtensible"/>
+ </xsd:schema>

package/skills/docx/scripts/office/schemas/microsoft/wml-cid-2016.xsd

@@ -0,0 +1,13 @@
+ <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:w12="http://schemas.openxmlformats.org/wordprocessingml/2006/main" elementFormDefault="qualified" attributeFormDefault="qualified" blockDefault="#all" xmlns="http://schemas.microsoft.com/office/word/2016/wordml/cid" targetNamespace="http://schemas.microsoft.com/office/word/2016/wordml/cid">
+   <xsd:import id="w12" namespace="http://schemas.openxmlformats.org/wordprocessingml/2006/main" schemaLocation="../ISO-IEC29500-4_2016/wml.xsd"/>
+   <xsd:complexType name="CT_CommentsIds">
+     <xsd:sequence>
+       <xsd:element name="commentId" type="CT_CommentId" minOccurs="0" maxOccurs="unbounded"/>
+     </xsd:sequence>
+   </xsd:complexType>
+   <xsd:complexType name="CT_CommentId">
+     <xsd:attribute name="paraId" type="w12:ST_LongHexNumber" use="required"/>
+     <xsd:attribute name="durableId" type="w12:ST_LongHexNumber" use="required"/>
+   </xsd:complexType>
+   <xsd:element name="commentsIds" type="CT_CommentsIds"/>
+ </xsd:schema>

package/skills/docx/scripts/office/schemas/microsoft/wml-sdtdatahash-2020.xsd

@@ -0,0 +1,4 @@
+ <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:w12="http://schemas.openxmlformats.org/wordprocessingml/2006/main" elementFormDefault="qualified" attributeFormDefault="qualified" blockDefault="#all" xmlns="http://schemas.microsoft.com/office/word/2020/wordml/sdtdatahash" targetNamespace="http://schemas.microsoft.com/office/word/2020/wordml/sdtdatahash">
+   <xsd:import id="w12" namespace="http://schemas.openxmlformats.org/wordprocessingml/2006/main" schemaLocation="../ISO-IEC29500-4_2016/wml.xsd"/>
+   <xsd:attribute name="storeItemChecksum" type="w12:ST_String"/>
+ </xsd:schema>

package/skills/docx/scripts/office/schemas/microsoft/wml-symex-2015.xsd

@@ -0,0 +1,8 @@
+ <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:w12="http://schemas.openxmlformats.org/wordprocessingml/2006/main" elementFormDefault="qualified" attributeFormDefault="qualified" blockDefault="#all" xmlns="http://schemas.microsoft.com/office/word/2015/wordml/symex" targetNamespace="http://schemas.microsoft.com/office/word/2015/wordml/symex">
+   <xsd:import id="w12" namespace="http://schemas.openxmlformats.org/wordprocessingml/2006/main" schemaLocation="../ISO-IEC29500-4_2016/wml.xsd"/>
+   <xsd:complexType name="CT_SymEx">
+     <xsd:attribute name="font" type="w12:ST_String"/>
+     <xsd:attribute name="char" type="w12:ST_LongHexNumber"/>
+   </xsd:complexType>
+   <xsd:element name="symEx" type="CT_SymEx"/>
+ </xsd:schema>

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

@@ -0,0 +1,194 @@
+"""
+Wrapper around LibreOffice (``soffice``) that transparently handles
+sandboxed environments where AF_UNIX sockets are unavailable.
+
+The module detects the restriction at startup and, when necessary,
+compiles and injects a tiny C shim via ``LD_PRELOAD``.
+
+Public surface::
+
+    from office.soffice import run_soffice, get_soffice_env
+
+    # Approach A – call soffice directly
+    result = run_soffice(["--headless", "--convert-to", "pdf", "input.docx"])
+
+    # Approach B – retrieve an env dict for manual subprocess usage
+    env = get_soffice_env()
+    subprocess.run(["soffice", ...], env=env)
+"""
+
+import os
+import pathlib
+import socket
+import subprocess
+import tempfile
+
+
+# ── Shared-object path for the optional shim ────────────────────────────────
+
+_COMPILED_SHIM = pathlib.Path(tempfile.gettempdir()) / "lo_socket_shim.so"
+
+# ── C source for the LD_PRELOAD shim ────────────────────────────────────────
+
+_C_SOURCE = 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 (*real_socket)(int, int, int);
+static int (*real_socketpair)(int, int, int, int[2]);
+static int (*real_listen)(int, int);
+static int (*real_accept)(int, struct sockaddr *, socklen_t *);
+static int (*real_close)(int);
+static int (*real_read)(int, void *, size_t);
+
+/* Per-FD bookkeeping (FDs >= 1024 are passed through unshimmed). */
+static int is_shimmed[1024];
+static int peer_of[1024];
+static int wake_r[1024];            /* accept() blocks reading this */
+static int wake_w[1024];            /* close()  writes to this      */
+static int listener_fd = -1;        /* FD that received listen()    */
+
+__attribute__((constructor))
+static void init(void) {
+    real_socket     = dlsym(RTLD_NEXT, "socket");
+    real_socketpair = dlsym(RTLD_NEXT, "socketpair");
+    real_listen     = dlsym(RTLD_NEXT, "listen");
+    real_accept     = dlsym(RTLD_NEXT, "accept");
+    real_close      = dlsym(RTLD_NEXT, "close");
+    real_read       = dlsym(RTLD_NEXT, "read");
+    for (int i = 0; i < 1024; i++) {
+        peer_of[i] = -1;
+        wake_r[i]  = -1;
+        wake_w[i]  = -1;
+    }
+}
+
+/* ---- socket ---------------------------------------------------------- */
+int socket(int domain, int type, int protocol) {
+    if (domain == AF_UNIX) {
+        int fd = real_socket(domain, type, protocol);
+        if (fd >= 0) return fd;
+        /* socket(AF_UNIX) blocked – fall back to socketpair(). */
+        int sv[2];
+        if (real_socketpair(domain, type, protocol, sv) == 0) {
+            if (sv[0] >= 0 && sv[0] < 1024) {
+                is_shimmed[sv[0]] = 1;
+                peer_of[sv[0]]    = sv[1];
+                int wp[2];
+                if (pipe(wp) == 0) {
+                    wake_r[sv[0]] = wp[0];
+                    wake_w[sv[0]] = wp[1];
+                }
+            }
+            return sv[0];
+        }
+        errno = EPERM;
+        return -1;
+    }
+    return real_socket(domain, type, protocol);
+}
+
+/* ---- listen ---------------------------------------------------------- */
+int listen(int sockfd, int backlog) {
+    if (sockfd >= 0 && sockfd < 1024 && is_shimmed[sockfd]) {
+        listener_fd = sockfd;
+        return 0;
+    }
+    return real_listen(sockfd, backlog);
+}
+
+/* ---- accept ---------------------------------------------------------- */
+int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen) {
+    if (sockfd >= 0 && sockfd < 1024 && is_shimmed[sockfd]) {
+        /* Block until close() writes to the wake pipe. */
+        if (wake_r[sockfd] >= 0) {
+            char buf;
+            real_read(wake_r[sockfd], &buf, 1);
+        }
+        errno = ECONNABORTED;
+        return -1;
+    }
+    return real_accept(sockfd, addr, addrlen);
+}
+
+/* ---- close ----------------------------------------------------------- */
+int close(int fd) {
+    if (fd >= 0 && fd < 1024 && is_shimmed[fd]) {
+        int was_listener = (fd == listener_fd);
+        is_shimmed[fd] = 0;
+
+        if (wake_w[fd] >= 0) {              /* unblock accept() */
+            char c = 0;
+            write(wake_w[fd], &c, 1);
+            real_close(wake_w[fd]);
+            wake_w[fd] = -1;
+        }
+        if (wake_r[fd] >= 0) { real_close(wake_r[fd]); wake_r[fd]  = -1; }
+        if (peer_of[fd] >= 0) { real_close(peer_of[fd]); peer_of[fd] = -1; }
+
+        if (was_listener)
+            _exit(0);                        /* conversion done – exit */
+    }
+    return real_close(fd);
+}
+"""
+
+
+# ── Internal helpers ─────────────────────────────────────────────────────────
+
+def _unix_sockets_blocked() -> bool:
+    """Return *True* when the OS refuses to create AF_UNIX sockets."""
+    try:
+        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        sock.close()
+        return False
+    except OSError:
+        return True
+
+
+def _build_shim_if_missing() -> pathlib.Path:
+    """Compile the C shim to a shared object when it is not yet present."""
+    if _COMPILED_SHIM.exists():
+        return _COMPILED_SHIM
+
+    c_file = pathlib.Path(tempfile.gettempdir()) / "lo_socket_shim.c"
+    c_file.write_text(_C_SOURCE)
+    subprocess.run(
+        ["gcc", "-shared", "-fPIC", "-o", str(_COMPILED_SHIM), str(c_file), "-ldl"],
+        check=True,
+        capture_output=True,
+    )
+    c_file.unlink()
+    return _COMPILED_SHIM
+
+
+# ── Public API ───────────────────────────────────────────────────────────────
+
+def get_soffice_env() -> dict:
+    """Return an ``env`` dict suitable for ``subprocess.run(env=…)``."""
+    merged = os.environ.copy()
+    merged["SAL_USE_VCLPLUGIN"] = "svp"
+
+    if _unix_sockets_blocked():
+        merged["LD_PRELOAD"] = str(_build_shim_if_missing())
+
+    return merged
+
+
+def run_soffice(args: list[str], **kw) -> subprocess.CompletedProcess:
+    """Launch ``soffice`` with the correct environment and given *args*."""
+    return subprocess.run(["soffice"] + args, env=get_soffice_env(), **kw)
+
+
+# ── CLI passthrough ──────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    import sys
+    outcome = run_soffice(sys.argv[1:])
+    sys.exit(outcome.returncode)

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

@@ -0,0 +1,145 @@
+"""Extract and beautify Office archives (DOCX / PPTX / XLSX) for manual XML editing.
+
+The ZIP contents are inflated, every XML file is pretty-printed, and — for
+Word documents — adjacent runs may be coalesced and redundant tracked-change
+wrappers collapsed.
+
+Invocation::
+
+    python unpack.py <office_file> <output_dir> [options]
+
+Samples::
+
+    python unpack.py document.docx unpacked/
+    python unpack.py presentation.pptx unpacked/
+    python unpack.py document.docx unpacked/ --merge-runs false
+"""
+
+import argparse
+import pathlib
+import sys
+import zipfile
+
+import defusedxml.minidom
+
+from helpers.merge_runs import merge_runs as _coalesce_runs
+from helpers.simplify_redlines import simplify_redlines as _compact_redlines
+
+_TYPOGRAPHIC_QUOTES = {
+    "\u201c": "&#x201C;",
+    "\u201d": "&#x201D;",
+    "\u2018": "&#x2018;",
+    "\u2019": "&#x2019;",
+}
+
+_OFFICE_SUFFIXES = {".docx", ".pptx", ".xlsx"}
+
+
+def _beautify_xml(fp: pathlib.Path) -> None:
+    """Rewrite *fp* in indented form via minidom."""
+    try:
+        raw = fp.read_text(encoding="utf-8")
+        dom = defusedxml.minidom.parseString(raw)
+        fp.write_bytes(dom.toprettyxml(indent="  ", encoding="utf-8"))
+    except Exception:
+        pass
+
+
+def _replace_typographic_quotes(fp: pathlib.Path) -> None:
+    """Convert Unicode curly quotes to XML numeric entities so they survive round-trips."""
+    try:
+        blob = fp.read_text(encoding="utf-8")
+        for ch, entity in _TYPOGRAPHIC_QUOTES.items():
+            blob = blob.replace(ch, entity)
+        fp.write_text(blob, encoding="utf-8")
+    except Exception:
+        pass
+
+
+def unpack(
+    input_file: str,
+    output_directory: str,
+    merge_runs: bool = True,
+    simplify_redlines: bool = True,
+) -> tuple[None, str]:
+    """Inflate *input_file* into *output_directory* and post-process XML."""
+    src = pathlib.Path(input_file)
+    dest = pathlib.Path(output_directory)
+    ext = src.suffix.lower()
+
+    if not src.exists():
+        return None, "Error: %s does not exist" % input_file
+
+    if ext not in _OFFICE_SUFFIXES:
+        return None, "Error: %s must be a .docx, .pptx, or .xlsx file" % input_file
+
+    try:
+        dest.mkdir(parents=True, exist_ok=True)
+
+        with zipfile.ZipFile(src, "r") as zf:
+            zf.extractall(dest)
+
+        xml_inventory = [
+            *dest.rglob("*.xml"),
+            *dest.rglob("*.rels"),
+        ]
+
+        for xf in xml_inventory:
+            _beautify_xml(xf)
+
+        summary = "Unpacked %s (%d XML files)" % (input_file, len(xml_inventory))
+
+        if ext == ".docx":
+            if simplify_redlines:
+                n_simplified, _ = _compact_redlines(str(dest))
+                summary += ", simplified %d tracked changes" % n_simplified
+
+            if merge_runs:
+                n_merged, _ = _coalesce_runs(str(dest))
+                summary += ", merged %d runs" % n_merged
+
+        for xf in xml_inventory:
+            _replace_typographic_quotes(xf)
+
+        return None, summary
+
+    except zipfile.BadZipFile:
+        return None, "Error: %s is not a valid Office file" % input_file
+    except Exception as exc:
+        return None, "Error unpacking: %s" % exc
+
+
+# ── CLI entry point ──────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser(
+        description="Unpack an Office file (DOCX, PPTX, XLSX) for editing"
+    )
+    ap.add_argument("input_file", help="Office file to unpack")
+    ap.add_argument("output_directory", help="Output directory")
+    ap.add_argument(
+        "--merge-runs",
+        type=lambda v: v.lower() == "true",
+        default=True,
+        metavar="true|false",
+        help="Merge adjacent runs with identical formatting (DOCX only, default: true)",
+    )
+    ap.add_argument(
+        "--simplify-redlines",
+        type=lambda v: v.lower() == "true",
+        default=True,
+        metavar="true|false",
+        help="Merge adjacent tracked changes from same author (DOCX only, default: true)",
+    )
+    cli = ap.parse_args()
+
+    _, message = unpack(
+        cli.input_file,
+        cli.output_directory,
+        merge_runs=cli.merge_runs,
+        simplify_redlines=cli.simplify_redlines,
+    )
+    print(message)
+
+    if "Error" in message:
+        sys.exit(1)

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

@@ -0,0 +1,114 @@
+"""
+CLI for checking Office XML against XSD schemas and tracked-change rules.
+
+Invocation::
+
+    python validate.py <path> [--original <original_file>] [--auto-repair] [--author NAME]
+
+``<path>`` may be either an already-unpacked directory **or** a packed
+``.docx``/``.pptx``/``.xlsx`` file (which is temporarily inflated).
+
+Auto-repair capabilities:
+
+* ``paraId`` / ``durableId`` values exceeding OOXML limits are regenerated.
+* Missing ``xml:space="preserve"`` on ``w:t`` nodes with leading/trailing
+  whitespace is injected.
+"""
+
+import argparse
+import pathlib
+import sys
+import tempfile
+import zipfile
+
+from validators import DOCXSchemaValidator, PPTXSchemaValidator, RedliningValidator
+
+_SUPPORTED_EXTS = [".docx", ".pptx", ".xlsx"]
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Validate Office document XML files")
+    ap.add_argument(
+        "path",
+        help="Path to unpacked directory or packed Office file (.docx/.pptx/.xlsx)",
+    )
+    ap.add_argument(
+        "--original",
+        required=False,
+        default=None,
+        help="Path to original file (.docx/.pptx/.xlsx). If omitted, all XSD errors are reported and redlining validation is skipped.",
+    )
+    ap.add_argument(
+        "-v", "--verbose",
+        action="store_true",
+        help="Enable verbose output",
+    )
+    ap.add_argument(
+        "--auto-repair",
+        action="store_true",
+        help="Automatically repair common issues (hex IDs, whitespace preservation)",
+    )
+    ap.add_argument(
+        "--author",
+        default="Claude",
+        help="Author name for redlining validation (default: Claude)",
+    )
+    opts = ap.parse_args()
+
+    target = pathlib.Path(opts.path)
+    assert target.exists(), "Error: %s does not exist" % target
+
+    ref_file = None
+    if opts.original:
+        ref_file = pathlib.Path(opts.original)
+        assert ref_file.is_file(), "Error: %s is not a file" % ref_file
+        assert ref_file.suffix.lower() in _SUPPORTED_EXTS, (
+            "Error: %s must be a .docx, .pptx, or .xlsx file" % ref_file
+        )
+
+    ext = (ref_file or target).suffix.lower()
+    assert ext in _SUPPORTED_EXTS, (
+        "Error: Cannot determine file type from %s. Use --original or provide a .docx/.pptx/.xlsx file." % target
+    )
+
+    if target.is_file() and target.suffix.lower() in _SUPPORTED_EXTS:
+        scratch = tempfile.mkdtemp()
+        with zipfile.ZipFile(target, "r") as zf:
+            zf.extractall(scratch)
+        work_dir = pathlib.Path(scratch)
+    else:
+        assert target.is_dir(), "Error: %s is not a directory or Office file" % target
+        work_dir = target
+
+    match ext:
+        case ".docx":
+            checkers = [
+                DOCXSchemaValidator(work_dir, ref_file, verbose=opts.verbose),
+            ]
+            if ref_file:
+                checkers.append(
+                    RedliningValidator(work_dir, ref_file, verbose=opts.verbose, author=opts.author)
+                )
+        case ".pptx":
+            checkers = [
+                PPTXSchemaValidator(work_dir, ref_file, verbose=opts.verbose),
+            ]
+        case _:
+            print("Error: Validation not supported for file type %s" % ext)
+            sys.exit(1)
+
+    if opts.auto_repair:
+        n_fixed = sum(c.repair() for c in checkers)
+        if n_fixed:
+            print("Auto-repaired %d issue(s)" % n_fixed)
+
+    ok = all(c.validate() for c in checkers)
+
+    if ok:
+        print("All validations PASSED!")
+
+    sys.exit(0 if ok else 1)
+
+
+if __name__ == "__main__":
+    main()

package/skills/docx/scripts/office/validators/__init__.py

@@ -0,0 +1,16 @@
+"""
+Office document validation toolkit — exposes checker classes for
+DOCX, PPTX, and tracked-change (redlining) scenarios.
+"""
+
+from .base import BaseSchemaValidator
+from .docx import DOCXSchemaValidator
+from .pptx import PPTXSchemaValidator
+from .redlining import RedliningValidator
+
+__all__ = [
+    "BaseSchemaValidator",
+    "DOCXSchemaValidator",
+    "PPTXSchemaValidator",
+    "RedliningValidator",
+]