@heylemon/lemonade 0.0.4 → 0.0.6

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

@@ -20,17 +20,8 @@ import subprocess
 import tempfile
 from pathlib import Path
 
-# ---------------------------------------------------------------------------
-# Public API
-# ---------------------------------------------------------------------------
 
 def get_soffice_env() -> dict:
-    """Return an env dict suitable for running soffice headlessly.
-
-    Always sets SAL_USE_VCLPLUGIN=svp for headless rendering (no X11).
-    In sandboxed environments where AF_UNIX sockets are blocked, also adds
-    LD_PRELOAD (socket shim).
-    """
     env = os.environ.copy()
     env["SAL_USE_VCLPLUGIN"] = "svp"
 
@@ -42,27 +33,15 @@ def get_soffice_env() -> dict:
 
 
 def run_soffice(args: list[str], **kwargs) -> subprocess.CompletedProcess:
-    """Run soffice with the given arguments, applying the socket shim
-    if needed.  Accepts the same keyword arguments as subprocess.run.
-
-    In sandboxed environments the shim handles clean shutdown by calling
-    _exit(0) when soffice.bin's listener socket closes (after conversion
-    is complete).  This avoids the hang that otherwise occurs because
-    oosplash gets stuck and never tells soffice.bin to quit.
-    """
     env = get_soffice_env()
     return subprocess.run(["soffice"] + args, env=env, **kwargs)
 
 
-# ---------------------------------------------------------------------------
-# Internals
-# ---------------------------------------------------------------------------
 
 _SHIM_SO = Path(tempfile.gettempdir()) / "lo_socket_shim.so"
 
 
 def _needs_shim() -> bool:
-    """Check whether AF_UNIX sockets are blocked."""
     try:
         s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
         s.close()
@@ -72,7 +51,6 @@ def _needs_shim() -> bool:
 
 
 def _ensure_shim() -> Path:
-    """Compile the shim .so if not already cached."""
     if _SHIM_SO.exists():
         return _SHIM_SO
 
@@ -87,36 +65,6 @@ def _ensure_shim() -> Path:
     return _SHIM_SO
 
 
-# ---------------------------------------------------------------------------
-# LD_PRELOAD shim – C source
-#
-# Problem
-# -------
-# LibreOffice uses AF_UNIX sockets for single-instance management
-# (OSL_PIPE).  In sandboxed environments the seccomp filter blocks
-# socket(AF_UNIX) while allowing socketpair(AF_UNIX).  Without this
-# shim, soffice either crashes or hangs after conversion:
-#
-#   1. oosplash (the LO launcher) creates a splash pipe, passes the
-#      write end to soffice.bin via --splash-pipe=<fd>, and blocks
-#      reading the read end.
-#   2. soffice.bin tries socket(AF_UNIX) → EPERM.  It crashes.
-#   3. With a minimal shim that fakes socket/bind/listen, soffice.bin
-#      starts and converts successfully – but then its main event loop
-#      idles forever waiting for oosplash (which is stuck) to signal
-#      quit.
-#
-# Solution
-# --------
-# Intercept the relevant calls and provide working substitutes:
-#
-#   socket(AF_UNIX)  → socketpair() fallback (real AF_UNIX FDs)
-#   listen()         → no-op on shimmed FDs
-#   accept()         → blocks on a wake-pipe until close() fires
-#   close()          → wakes accept(), cleans up, and – when the
-#                      listener socket is closed – calls _exit(0)
-#                      to terminate cleanly after conversion.
-# ---------------------------------------------------------------------------
 
 _SHIM_SOURCE = r"""
 #define _GNU_SOURCE
@@ -228,9 +176,6 @@ int close(int fd) {
 """
 
 
-# ---------------------------------------------------------------------------
-# CLI entry point
-# ---------------------------------------------------------------------------
 
 if __name__ == "__main__":
     import sys

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

@@ -1,4 +1,3 @@
-#!/usr/bin/env python3
 """Unpack Office files (DOCX, PPTX, XLSX) for editing.
 
 Extracts the ZIP archive, pretty-prints XML files, and optionally:
@@ -24,12 +23,11 @@ import defusedxml.minidom
 from helpers.merge_runs import merge_runs as do_merge_runs
 from helpers.simplify_redlines import simplify_redlines as do_simplify_redlines
 
-# Smart quotes that get mangled by the tokenizer - convert to XML entities
 SMART_QUOTE_REPLACEMENTS = {
-    "\u201c": "“",  # Left double quote "
-    "\u201d": "”",  # Right double quote "
-    "\u2018": "‘",  # Left single quote '
-    "\u2019": "’",  # Right single quote '
+    "\u201c": "“",  
+    "\u201d": "”",  
+    "\u2018": "‘",  
+    "\u2019": "’",  
 }
 
 
@@ -39,17 +37,6 @@ def unpack(
     merge_runs: bool = True,
     simplify_redlines: bool = True,
 ) -> tuple[None, str]:
-    """Unpack an Office file and prepare for editing.
-
-    Args:
-        input_file: Path to Office file (.docx, .pptx, .xlsx)
-        output_directory: Path to output directory
-        merge_runs: If True, merge adjacent runs with identical formatting (DOCX only)
-        simplify_redlines: If True, merge adjacent tracked changes from same author (DOCX only)
-
-    Returns:
-        (None, message) - message indicates success or failure
-    """
     input_path = Path(input_file)
     output_path = Path(output_directory)
     suffix = input_path.suffix.lower()
@@ -61,33 +48,26 @@ def unpack(
         return None, f"Error: {input_file} must be a .docx, .pptx, or .xlsx file"
 
     try:
-        # Create output directory
         output_path.mkdir(parents=True, exist_ok=True)
 
-        # Extract ZIP contents
         with zipfile.ZipFile(input_path, "r") as zf:
             zf.extractall(output_path)
 
-        # Pretty print all XML files
         xml_files = list(output_path.rglob("*.xml")) + list(output_path.rglob("*.rels"))
         for xml_file in xml_files:
             _pretty_print_xml(xml_file)
 
         message = f"Unpacked {input_file} ({len(xml_files)} XML files)"
 
-        # DOCX-specific processing
         if suffix == ".docx":
-            # Simplify tracked changes (before merge_runs so more runs can merge)
             if simplify_redlines:
                 simplify_count, _ = do_simplify_redlines(str(output_path))
                 message += f", simplified {simplify_count} tracked changes"
 
-            # Merge runs
             if merge_runs:
                 merge_count, _ = do_merge_runs(str(output_path))
                 message += f", merged {merge_count} runs"
 
-        # Escape smart quotes AFTER transformations (which rewrite files)
         for xml_file in xml_files:
             _escape_smart_quotes(xml_file)
 
@@ -100,17 +80,15 @@ def unpack(
 
 
 def _pretty_print_xml(xml_file: Path) -> None:
-    """Pretty print an XML file with indentation."""
     try:
         content = xml_file.read_text(encoding="utf-8")
         dom = defusedxml.minidom.parseString(content)
         xml_file.write_bytes(dom.toprettyxml(indent="  ", encoding="utf-8"))
     except Exception:
-        pass  # Skip files that can't be parsed
+        pass  
 
 
 def _escape_smart_quotes(xml_file: Path) -> None:
-    """Replace smart quotes with XML entities so they survive tokenization."""
     try:
         content = xml_file.read_text(encoding="utf-8")
         for char, entity in SMART_QUOTE_REPLACEMENTS.items():

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

@@ -1,9 +1,8 @@
-#!/usr/bin/env python3
 """
 Command line tool to validate Office document XML files against XSD schemas and tracked changes.
 
 Usage:
-    python validate.py <path> --original <original_file> [--auto-repair] [--author NAME]
+    python validate.py <path> [--original <original_file>] [--auto-repair] [--author NAME]
 
 The first argument can be either:
 - An unpacked directory containing the Office document XML files
@@ -31,8 +30,9 @@ def main():
     )
     parser.add_argument(
         "--original",
-        required=True,
-        help="Path to original file (.docx/.pptx/.xlsx)",
+        required=False,
+        default=None,
+        help="Path to original file (.docx/.pptx/.xlsx). If omitted, all XSD errors are reported and redlining validation is skipped.",
     )
     parser.add_argument(
         "-v",
@@ -52,17 +52,22 @@ def main():
     )
     args = parser.parse_args()
 
-    # Validate paths
     path = Path(args.path)
-    original_file = Path(args.original)
-    file_extension = original_file.suffix.lower()
     assert path.exists(), f"Error: {path} does not exist"
-    assert original_file.is_file(), f"Error: {original_file} is not a file"
+
+    original_file = None
+    if args.original:
+        original_file = Path(args.original)
+        assert original_file.is_file(), f"Error: {original_file} is not a file"
+        assert original_file.suffix.lower() in [".docx", ".pptx", ".xlsx"], (
+            f"Error: {original_file} must be a .docx, .pptx, or .xlsx file"
+        )
+
+    file_extension = (original_file or path).suffix.lower()
     assert file_extension in [".docx", ".pptx", ".xlsx"], (
-        f"Error: {original_file} must be a .docx, .pptx, or .xlsx file"
+        f"Error: Cannot determine file type from {path}. Use --original or provide a .docx/.pptx/.xlsx file."
     )
 
-    # If path is a packed file, unpack to temp directory
     if path.is_file() and path.suffix.lower() in [".docx", ".pptx", ".xlsx"]:
         temp_dir = tempfile.mkdtemp()
         with zipfile.ZipFile(path, "r") as zf:
@@ -72,13 +77,15 @@ def main():
         assert path.is_dir(), f"Error: {path} is not a directory or Office file"
         unpacked_dir = path
 
-    # Create validators based on file type
     match file_extension:
         case ".docx":
             validators = [
                 DOCXSchemaValidator(unpacked_dir, original_file, verbose=args.verbose),
-                RedliningValidator(unpacked_dir, original_file, verbose=args.verbose, author=args.author),
             ]
+            if original_file:
+                validators.append(
+                    RedliningValidator(unpacked_dir, original_file, verbose=args.verbose, author=args.author)  
+                )
         case ".pptx":
             validators = [
                 PPTXSchemaValidator(unpacked_dir, original_file, verbose=args.verbose),
@@ -87,13 +94,11 @@ def main():
             print(f"Error: Validation not supported for file type {file_extension}")
             sys.exit(1)
 
-    # Auto-repair if requested
     if args.auto_repair:
         total_repairs = sum(v.repair() for v in validators)
         if total_repairs:
             print(f"Auto-repaired {total_repairs} issue(s)")
 
-    # Run validators
     success = all(v.validate() for v in validators)
 
     if success: