@panda-agent/panda-cli 0.1.29 → 0.1.30

package/skills/xlsx/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/xlsx/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/xlsx/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/xlsx/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/xlsx/scripts/office/soffice.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+# ──────────────────────────────────────────────────────────────────
+# LibreOffice runner with automatic AF_UNIX socket shim.
+#
+# Provides two public entry-points:
+#
+#   get_soffice_env()  → dict   –  environment dict for subprocess calls
+#   run_soffice(args)  → CompletedProcess
+#
+# When the host kernel blocks AF_UNIX sockets (common in sandboxed VMs),
+# a small C shim is compiled on-the-fly and injected via LD_PRELOAD.
+# ──────────────────────────────────────────────────────────────────
+
+import os
+import socket
+import subprocess
+import tempfile
+from pathlib import Path
+
+
+# ── compiled shim location ──
+_COMPILED_SHIM = Path(tempfile.gettempdir()) / "lo_socket_shim.so"
+
+
+def get_soffice_env() -> dict:
+    """Return a copy of os.environ with LibreOffice-specific tweaks."""
+    env = dict(os.environ)
+    env["SAL_USE_VCLPLUGIN"] = "svp"
+
+    if _host_needs_shim():
+        env["LD_PRELOAD"] = str(_build_shim_if_needed())
+
+    return env
+
+
+def run_soffice(args: list[str], **kw) -> subprocess.CompletedProcess:
+    """Convenience wrapper: call soffice with the patched environment."""
+    return subprocess.run(["soffice"] + args, env=get_soffice_env(), **kw)
+
+
+# ──────────────────────────────────────────────────────────────────
+# private helpers
+# ──────────────────────────────────────────────────────────────────
+
+def _host_needs_shim() -> bool:
+    """Return True when creating AF_UNIX sockets raises OSError."""
+    try:
+        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        sock.close()
+    except OSError:
+        return True
+    return False
+
+
+def _build_shim_if_needed() -> Path:
+    """Compile the C shim once and cache the .so in /tmp."""
+    if _COMPILED_SHIM.exists():
+        return _COMPILED_SHIM
+
+    c_src = Path(tempfile.gettempdir()) / "lo_socket_shim.c"
+    c_src.write_text(_C_SHIM_CODE)
+    subprocess.run(
+        ["gcc", "-shared", "-fPIC", "-o", str(_COMPILED_SHIM), str(c_src), "-ldl"],
+        check=True,
+        capture_output=True,
+    )
+    c_src.unlink()
+    return _COMPILED_SHIM
+
+
+# ── inline C source for the LD_PRELOAD shim ──
+_C_SHIM_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 (*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);
+}
+"""
+
+
+if __name__ == "__main__":
+    import sys
+    rc = run_soffice(sys.argv[1:])
+    sys.exit(rc.returncode)

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

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+# ──────────────────────────────────────────────────────────────────
+# Extract Office archives (DOCX / PPTX / XLSX) into an editable tree.
+#
+# After extraction, XML is pretty-printed for readability. For DOCX
+# files two optional post-processing passes are available:
+#   • run-merging   – coalesce adjacent <w:r> with matching properties
+#   • redline-simplification – coalesce adjacent <w:ins>/<w:del> tags
+#
+# CLI:
+#   python unpack.py <office_file> <out_dir> [--merge-runs true|false]
+#                                             [--simplify-redlines true|false]
+# ──────────────────────────────────────────────────────────────────
+
+import argparse
+import sys
+import zipfile
+from pathlib import Path
+
+import defusedxml.minidom
+
+from helpers.merge_runs import merge_runs as _coalesce_runs
+from helpers.simplify_redlines import simplify_redlines as _coalesce_redlines
+
+# Unicode curly-quote → XML entity mapping
+_CURLY_QUOTES = {
+    "\u201c": "&#x201C;",
+    "\u201d": "&#x201D;",
+    "\u2018": "&#x2018;",
+    "\u2019": "&#x2019;",
+}
+
+_OFFICE_SUFFIXES = {".docx", ".pptx", ".xlsx"}
+
+
+def unpack(
+    src_file: str,
+    out_dir: str,
+    coalesce_runs: bool = True,
+    coalesce_redlines: bool = True,
+) -> tuple[None, str]:
+    """Extract *src_file* into *out_dir* and post-process XML."""
+    src = Path(src_file)
+    dest = Path(out_dir)
+    ext = src.suffix.lower()
+
+    if not src.exists():
+        return None, "Error: {} does not exist".format(src_file)
+
+    if ext not in _OFFICE_SUFFIXES:
+        return None, "Error: {} must be a .docx, .pptx, or .xlsx file".format(src_file)
+
+    try:
+        dest.mkdir(parents=True, exist_ok=True)
+
+        with zipfile.ZipFile(src, "r") as archive:
+            archive.extractall(dest)
+
+        xml_paths = [
+            p for p in list(dest.rglob("*.xml")) + list(dest.rglob("*.rels"))
+        ]
+
+        for xp in xml_paths:
+            _reformat_xml(xp)
+
+        info = "Unpacked {} ({} XML files)".format(src_file, len(xml_paths))
+
+        # DOCX-specific post-processing
+        if ext == ".docx":
+            if coalesce_redlines:
+                n, _ = _coalesce_redlines(str(dest))
+                info += ", simplified {} tracked changes".format(n)
+            if coalesce_runs:
+                n, _ = _coalesce_runs(str(dest))
+                info += ", merged {} runs".format(n)
+
+        for xp in xml_paths:
+            _encode_curly_quotes(xp)
+
+        return None, info
+
+    except zipfile.BadZipFile:
+        return None, "Error: {} is not a valid Office file".format(src_file)
+    except Exception as exc:
+        return None, "Error unpacking: {}".format(exc)
+
+
+# ──────────────────────────────────────────────────────────────────
+
+def _reformat_xml(fp: Path) -> None:
+    """Pretty-print an XML file in-place (2-space indent)."""
+    try:
+        raw = fp.read_text(encoding="utf-8")
+        doc = defusedxml.minidom.parseString(raw)
+        fp.write_bytes(doc.toprettyxml(indent="  ", encoding="utf-8"))
+    except Exception:
+        pass
+
+
+def _encode_curly_quotes(fp: Path) -> None:
+    """Replace curly quotes with their XML entity equivalents."""
+    try:
+        data = fp.read_text(encoding="utf-8")
+        for ch, ent in _CURLY_QUOTES.items():
+            data = data.replace(ch, ent)
+        fp.write_text(data, encoding="utf-8")
+    except Exception:
+        pass
+
+
+# ──────────────────────────────────────────────────────────────────
+# CLI
+# ──────────────────────────────────────────────────────────────────
+
+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 x: x.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 x: x.lower() == "true",
+        default=True,
+        metavar="true|false",
+        help="Merge adjacent tracked changes from same author (DOCX only, default: true)",
+    )
+    ns = ap.parse_args()
+
+    _, msg = unpack(
+        ns.input_file,
+        ns.output_directory,
+        coalesce_runs=ns.merge_runs,
+        coalesce_redlines=ns.simplify_redlines,
+    )
+    print(msg)
+
+    if "Error" in msg:
+        sys.exit(1)

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

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+# ──────────────────────────────────────────────────────────────────
+# Standalone CLI for validating unpacked Office XML against XSD schemas
+# and checking tracked-change consistency.
+#
+# Accepts either an unpacked directory or a packed .docx/.pptx/.xlsx
+# (the latter is extracted to a temp dir automatically).
+#
+# Auto-repair capabilities:
+#   • paraId / durableId values exceeding OOXML limits
+#   • Missing xml:space="preserve" on <w:t> elements with whitespace
+# ──────────────────────────────────────────────────────────────────
+
+import argparse
+import sys
+import tempfile
+import zipfile
+from pathlib import Path
+
+from validators import DOCXSchemaValidator, PPTXSchemaValidator, RedliningValidator
+
+_VALID_SUFFIXES = [".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 = Path(opts.path)
+    assert target.exists(), "Error: {} does not exist".format(target)
+
+    orig = None
+    if opts.original is not None:
+        orig = Path(opts.original)
+        assert orig.is_file(), "Error: {} is not a file".format(orig)
+        assert orig.suffix.lower() in _VALID_SUFFIXES, (
+            "Error: {} must be a .docx, .pptx, or .xlsx file".format(orig)
+        )
+
+    detected_ext = (orig or target).suffix.lower()
+    assert detected_ext in _VALID_SUFFIXES, (
+        "Error: Cannot determine file type from {}. "
+        "Use --original or provide a .docx/.pptx/.xlsx file.".format(target)
+    )
+
+    # Auto-extract packed files into a temp directory
+    if target.is_file() and target.suffix.lower() in _VALID_SUFFIXES:
+        tmp = tempfile.mkdtemp()
+        with zipfile.ZipFile(target, "r") as zf:
+            zf.extractall(tmp)
+        work_dir = Path(tmp)
+    else:
+        assert target.is_dir(), "Error: {} is not a directory or Office file".format(target)
+        work_dir = target
+
+    # Build the appropriate validator chain
+    match detected_ext:
+        case ".docx":
+            checkers = [
+                DOCXSchemaValidator(work_dir, orig, verbose=opts.verbose),
+            ]
+            if orig is not None:
+                checkers.append(
+                    RedliningValidator(work_dir, orig, verbose=opts.verbose, author=opts.author)
+                )
+        case ".pptx":
+            checkers = [
+                PPTXSchemaValidator(work_dir, orig, verbose=opts.verbose),
+            ]
+        case _:
+            print("Error: Validation not supported for file type {}".format(detected_ext))
+            sys.exit(1)
+
+    if opts.auto_repair:
+        n_fixed = sum(c.repair() for c in checkers)
+        if n_fixed:
+            print("Auto-repaired {} issue(s)".format(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/xlsx/scripts/office/validators/__init__.py

@@ -0,0 +1,13 @@
+# ── Office document validation sub-package ──
+
+from .base import BaseSchemaValidator
+from .docx import DOCXSchemaValidator
+from .pptx import PPTXSchemaValidator
+from .redlining import RedliningValidator
+
+__all__ = [
+    "BaseSchemaValidator",
+    "DOCXSchemaValidator",
+    "PPTXSchemaValidator",
+    "RedliningValidator",
+]