@panda-agent/panda-cli 0.1.29 → 0.1.31

package/bundled-preset-skills/xlsx/scripts/office/validators/redlining.py

@@ -0,0 +1,229 @@
+#!/usr/bin/env python3
+# ──────────────────────────────────────────────────────────────────
+# Tracked-change (redlining) consistency validator for DOCX.
+#
+# Verifies that the textual content of the modified document matches
+# the original *after* stripping out all tracked changes attributed
+# to the specified author.  If there's a mismatch, a word-level diff
+# is produced via `git diff --word-diff`.
+# ──────────────────────────────────────────────────────────────────
+
+import subprocess
+import tempfile
+import zipfile
+from pathlib import Path
+
+_W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+
+
+class RedliningValidator:
+    """Ensure that an author's changes are fully tracked in the DOCX XML."""
+
+    def __init__(self, unpacked_dir, original_docx, verbose=False, author="Claude"):
+        self.work_dir = Path(unpacked_dir)
+        self.ref_docx = Path(original_docx)
+        self.verbose = verbose
+        self.author = author
+        self._ns = {"w": _W_NS}
+
+    # kept for interface compat
+    @property
+    def unpacked_dir(self):
+        return self.work_dir
+
+    @property
+    def original_docx(self):
+        return self.ref_docx
+
+    @property
+    def namespaces(self):
+        return self._ns
+
+    def repair(self) -> int:
+        return 0
+
+    # ──────────────────────────────────────────────────────────────
+
+    def validate(self):
+        mod_xml = self.work_dir / "word" / "document.xml"
+        if not mod_xml.exists():
+            print("FAILED - Modified document.xml not found at {}".format(mod_xml))
+            return False
+
+        # Quick check: any tracked changes by this author?
+        try:
+            import xml.etree.ElementTree as ET
+
+            tree = ET.parse(mod_xml)
+            root = tree.getroot()
+
+            w_author = "{{{}}}author".format(_W_NS)
+            del_by_author = [
+                e for e in root.findall(".//w:del", self._ns)
+                if e.get(w_author) == self.author
+            ]
+            ins_by_author = [
+                e for e in root.findall(".//w:ins", self._ns)
+                if e.get(w_author) == self.author
+            ]
+            if not del_by_author and not ins_by_author:
+                if self.verbose:
+                    print("PASSED - No tracked changes by {} found.".format(self.author))
+                return True
+        except Exception:
+            pass
+
+        # Full comparison
+        with tempfile.TemporaryDirectory() as td:
+            tmp = Path(td)
+
+            try:
+                with zipfile.ZipFile(self.ref_docx, "r") as zf:
+                    zf.extractall(tmp)
+            except Exception as exc:
+                print("FAILED - Error unpacking original docx: {}".format(exc))
+                return False
+
+            orig_xml = tmp / "word" / "document.xml"
+            if not orig_xml.exists():
+                print("FAILED - Original document.xml not found in {}".format(self.ref_docx))
+                return False
+
+            try:
+                import xml.etree.ElementTree as ET
+
+                mod_root = ET.parse(mod_xml).getroot()
+                orig_root = ET.parse(orig_xml).getroot()
+            except ET.ParseError as exc:
+                print("FAILED - Error parsing XML files: {}".format(exc))
+                return False
+
+            self._strip_author_changes(orig_root)
+            self._strip_author_changes(mod_root)
+
+            txt_mod = self._body_text(mod_root)
+            txt_orig = self._body_text(orig_root)
+
+            if txt_mod != txt_orig:
+                print(self._build_diff_report(txt_orig, txt_mod))
+                return False
+
+        if self.verbose:
+            print("PASSED - All changes by {} are properly tracked".format(self.author))
+        return True
+
+    # ──────────────────────────────────────────────────────────────
+    # Diff report generation
+    # ──────────────────────────────────────────────────────────────
+
+    def _build_diff_report(self, old_text, new_text):
+        parts = [
+            "FAILED - Document text doesn't match after removing {}'s tracked changes".format(self.author),
+            "",
+            "Likely causes:",
+            "  1. Modified text inside another author's <w:ins> or <w:del> tags",
+            "  2. Made edits without proper tracked changes",
+            "  3. Didn't nest <w:del> inside <w:ins> when deleting another's insertion",
+            "",
+            "For pre-redlined documents, use correct patterns:",
+            "  - To reject another's INSERTION: Nest <w:del> inside their <w:ins>",
+            "  - To restore another's DELETION: Add new <w:ins> AFTER their <w:del>",
+            "",
+        ]
+        diff = self._word_diff(old_text, new_text)
+        if diff:
+            parts += ["Differences:", "============", diff]
+        else:
+            parts.append("Unable to generate word diff (git not available)")
+        return "\n".join(parts)
+
+    def _word_diff(self, a, b):
+        """Produce a character-level word diff using git."""
+        try:
+            with tempfile.TemporaryDirectory() as td:
+                p = Path(td)
+                fa, fb = p / "original.txt", p / "modified.txt"
+                fa.write_text(a, encoding="utf-8")
+                fb.write_text(b, encoding="utf-8")
+
+                for extra_args in (
+                    ["--word-diff-regex=."],
+                    [],
+                ):
+                    proc = subprocess.run(
+                        [
+                            "git", "diff", "--word-diff=plain", "-U0",
+                            "--no-index", str(fa), str(fb),
+                        ] + extra_args,
+                        capture_output=True, text=True,
+                    )
+                    if not proc.stdout.strip():
+                        continue
+                    content = []
+                    active = False
+                    for line in proc.stdout.split("\n"):
+                        if line.startswith("@@"):
+                            active = True
+                            continue
+                        if active and line.strip():
+                            content.append(line)
+                    if content:
+                        return "\n".join(content)
+
+        except (subprocess.CalledProcessError, FileNotFoundError, Exception):
+            pass
+        return None
+
+    # ──────────────────────────────────────────────────────────────
+    # XML manipulation
+    # ──────────────────────────────────────────────────────────────
+
+    def _strip_author_changes(self, root):
+        """Remove this author's tracked insertions; inline their deletions."""
+        ins_tag = "{{{}}}ins".format(_W_NS)
+        del_tag = "{{{}}}del".format(_W_NS)
+        auth_key = "{{{}}}author".format(_W_NS)
+
+        # Pass 1: remove <w:ins> by this author entirely
+        for parent in root.iter():
+            doomed = [
+                ch for ch in parent
+                if ch.tag == ins_tag and ch.get(auth_key) == self.author
+            ]
+            for el in doomed:
+                parent.remove(el)
+
+        # Pass 2: inline <w:del> by this author (convert delText → t)
+        deltext_tag = "{{{}}}delText".format(_W_NS)
+        t_tag = "{{{}}}t".format(_W_NS)
+
+        for parent in root.iter():
+            targets = [
+                (ch, list(parent).index(ch))
+                for ch in parent
+                if ch.tag == del_tag and ch.get(auth_key) == self.author
+            ]
+            for del_el, idx in reversed(targets):
+                for nd in del_el.iter():
+                    if nd.tag == deltext_tag:
+                        nd.tag = t_tag
+                for kid in reversed(list(del_el)):
+                    parent.insert(idx, kid)
+                parent.remove(del_el)
+
+    def _body_text(self, root):
+        """Extract the visible paragraph text from the document body."""
+        p_tag = "{{{}}}p".format(_W_NS)
+        t_tag = "{{{}}}t".format(_W_NS)
+
+        paragraphs = []
+        for p in root.findall(".//{}".format(p_tag)):
+            pieces = [t.text for t in p.findall(".//{}".format(t_tag)) if t.text]
+            joined = "".join(pieces)
+            if joined:
+                paragraphs.append(joined)
+        return "\n".join(paragraphs)
+
+
+if __name__ == "__main__":
+    raise RuntimeError("This module should not be run directly.")

package/bundled-preset-skills/xlsx/scripts/recalc.py

@@ -0,0 +1,296 @@
+#!/usr/bin/env python3
+"""Spreadsheet formula recalculation via LibreOffice.
+
+Deploys a LibreOffice Basic macro, invokes headless recalculation on an Excel
+workbook, then scans all cells for error markers and emits a structured JSON
+report to stdout.
+
+Usage:
+    python recalc.py <excel_file> [timeout_seconds]
+"""
+
+from __future__ import annotations
+
+import json
+import platform
+import subprocess
+import sys
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Optional
+
+import openpyxl
+
+from office.soffice import get_soffice_env
+
+# ─── Platform Constants ──────────────────────────────────────────────
+
+_SYSTEM = platform.system()
+
+_MACRO_BASE_DIRS: dict[str, str] = {
+    "Darwin": "~/Library/Application Support/LibreOffice/4/user/basic/Standard",
+    "Linux": "~/.config/libreoffice/4/user/basic/Standard",
+}
+
+_MACRO_MODULE_NAME = "Module1.xba"
+
+_MACRO_ENTRY_POINT = (
+    "vnd.sun.star.script:Standard.Module1.RecalculateAndSave"
+    "?language=Basic&location=application"
+)
+
+_MACRO_XML = (
+    '<?xml version="1.0" encoding="UTF-8"?>\n'
+    '<!DOCTYPE script:module PUBLIC '
+    '"-//OpenOffice.org//DTD OfficeDocument 1.0//EN" "module.dtd">\n'
+    '<script:module xmlns:script="http://openoffice.org/2000/script" '
+    'script:name="Module1" script:language="StarBasic">\n'
+    "    Sub RecalculateAndSave()\n"
+    "      ThisComponent.calculateAll()\n"
+    "      ThisComponent.store()\n"
+    "      ThisComponent.close(True)\n"
+    "    End Sub\n"
+    "</script:module>"
+)
+
+# ─── Excel Error Markers ─────────────────────────────────────────────
+
+CELL_ERROR_MARKERS: tuple[str, ...] = (
+    "#VALUE!", "#DIV/0!", "#REF!", "#NAME?", "#NULL!", "#NUM!", "#N/A",
+)
+
+_MAX_ERROR_LOCATIONS = 20
+_DEFAULT_TIMEOUT_SECONDS = 30
+_TIMEOUT_EXIT_CODE = 124
+
+
+# ─── Data Structures ─────────────────────────────────────────────────
+
+@dataclass
+class ErrorBucket:
+    """Aggregated info for one category of cell errors."""
+    count: int
+    locations: list[str]
+
+
+@dataclass
+class RecalcReport:
+    """Structured result of a recalculation + error-scan pass."""
+    status: str = "success"
+    total_errors: int = 0
+    total_formulas: int = 0
+    error_summary: dict[str, ErrorBucket] = field(default_factory=dict)
+    error: Optional[str] = None
+
+    def to_dict(self) -> dict:
+        """Serialise to a plain dict matching the original JSON contract."""
+        result: dict = {}
+        if self.error is not None:
+            result["error"] = self.error
+            return result
+        result["status"] = self.status
+        result["total_errors"] = self.total_errors
+        result["error_summary"] = {
+            kind: asdict(bucket) for kind, bucket in self.error_summary.items()
+        }
+        result["total_formulas"] = self.total_formulas
+        return result
+
+
+# ─── Timeout Utility ─────────────────────────────────────────────────
+
+def _has_gtimeout() -> bool:
+    """Check whether GNU coreutils ``gtimeout`` binary exists on this host."""
+    try:
+        subprocess.run(
+            ["gtimeout", "--version"],
+            capture_output=True,
+            timeout=1,
+            check=False,
+        )
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return False
+    return True
+
+
+# ─── Macro Deployment ────────────────────────────────────────────────
+
+def _deploy_macro() -> bool:
+    """Ensure the RecalculateAndSave Basic macro is present in the LO user dir.
+
+    Returns ``True`` on success, ``False`` if LibreOffice is missing or the
+    macro file could not be written.
+    """
+    base_template = _MACRO_BASE_DIRS.get(_SYSTEM, _MACRO_BASE_DIRS["Linux"])
+    base_dir = Path(base_template).expanduser()
+    target = base_dir / _MACRO_MODULE_NAME
+
+    # Already deployed?
+    if target.exists() and "RecalculateAndSave" in target.read_text():
+        return True
+
+    # Bootstrap LibreOffice profile when the directory tree is missing.
+    if not base_dir.exists():
+        try:
+            subprocess.run(
+                ["soffice", "--headless", "--terminate_after_init"],
+                capture_output=True,
+                timeout=10,
+                env=get_soffice_env(),
+            )
+        except FileNotFoundError:
+            return False
+        base_dir.mkdir(parents=True, exist_ok=True)
+
+    try:
+        target.write_text(_MACRO_XML)
+    except OSError:
+        return False
+    return True
+
+
+# ─── Workbook Inspection ─────────────────────────────────────────────
+
+def _count_formulas(filepath: Path) -> int:
+    """Open *filepath* without cached values and count formula cells."""
+    wb = openpyxl.load_workbook(str(filepath), data_only=False)
+    total = 0
+    for sheet_name in wb.sheetnames:
+        ws = wb[sheet_name]
+        for row in ws.iter_rows():
+            for cell in row:
+                if isinstance(cell.value, str) and cell.value.startswith("="):
+                    total += 1
+    wb.close()
+    return total
+
+
+def _scan_errors(filepath: Path) -> tuple[int, dict[str, ErrorBucket]]:
+    """Scan cached cell values for Excel error strings.
+
+    Returns a ``(total_error_count, buckets)`` tuple where *buckets* maps each
+    error marker that has at least one occurrence to an :class:`ErrorBucket`.
+    """
+    wb = openpyxl.load_workbook(str(filepath), data_only=True)
+    raw_buckets: dict[str, list[str]] = {m: [] for m in CELL_ERROR_MARKERS}
+    total = 0
+
+    for sheet_name in wb.sheetnames:
+        ws = wb[sheet_name]
+        for row in ws.iter_rows():
+            for cell in row:
+                if cell.value is None or not isinstance(cell.value, str):
+                    continue
+                for marker in CELL_ERROR_MARKERS:
+                    if marker in cell.value:
+                        raw_buckets[marker].append(
+                            f"{sheet_name}!{cell.coordinate}"
+                        )
+                        total += 1
+                        break
+
+    wb.close()
+
+    buckets: dict[str, ErrorBucket] = {}
+    for kind, locs in raw_buckets.items():
+        if locs:
+            buckets[kind] = ErrorBucket(
+                count=len(locs),
+                locations=locs[:_MAX_ERROR_LOCATIONS],
+            )
+
+    return total, buckets
+
+
+# ─── Core Recalculation ──────────────────────────────────────────────
+
+def _build_command(filepath: str, timeout: int) -> list[str]:
+    """Assemble the ``soffice`` invocation with optional timeout wrapper."""
+    argv = [
+        "soffice", "--headless", "--norestore",
+        _MACRO_ENTRY_POINT,
+        filepath,
+    ]
+
+    if _SYSTEM == "Linux":
+        argv = ["timeout", str(timeout)] + argv
+    elif _SYSTEM == "Darwin" and _has_gtimeout():
+        argv = ["gtimeout", str(timeout)] + argv
+
+    return argv
+
+
+def recalc(filename: str, timeout: int = _DEFAULT_TIMEOUT_SECONDS) -> dict:
+    """Run the LO macro on *filename* then inspect the result for errors.
+
+    Returns a plain ``dict`` suitable for JSON serialisation.
+    """
+    source = Path(filename)
+
+    if not source.exists():
+        return RecalcReport(error=f"File {filename} does not exist").to_dict()
+
+    absolute_path = str(source.absolute())
+
+    if not _deploy_macro():
+        return RecalcReport(error="Failed to setup LibreOffice macro").to_dict()
+
+    argv = _build_command(absolute_path, timeout)
+
+    try:
+        proc = subprocess.run(
+            argv, capture_output=True, text=True, env=get_soffice_env(),
+        )
+    except FileNotFoundError:
+        return RecalcReport(
+            error="LibreOffice (soffice) is not installed or not in PATH",
+        ).to_dict()
+
+    if proc.returncode not in (0, _TIMEOUT_EXIT_CODE):
+        msg = proc.stderr or "Unknown error during recalculation"
+        if "Module1" in msg or "RecalculateAndSave" not in msg:
+            return RecalcReport(
+                error="LibreOffice macro not configured properly",
+            ).to_dict()
+        return RecalcReport(error=msg).to_dict()
+
+    try:
+        err_total, buckets = _scan_errors(source)
+
+        report = RecalcReport(
+            status="success" if err_total == 0 else "errors_found",
+            total_errors=err_total,
+            error_summary=buckets,
+            total_formulas=_count_formulas(source),
+        )
+        return report.to_dict()
+
+    except Exception as exc:
+        return RecalcReport(error=str(exc)).to_dict()
+
+
+# ─── CLI Entry Point ─────────────────────────────────────────────────
+
+def main() -> None:
+    """Parse CLI arguments and run recalculation."""
+    if len(sys.argv) < 2:
+        sys.stderr.write(
+            "Usage: python recalc.py <excel_file> [timeout_seconds]\n\n"
+            "Recalculates all formulas in an Excel file using LibreOffice\n\n"
+            "Returns JSON with error details:\n"
+            "  - status: 'success' or 'errors_found'\n"
+            "  - total_errors: Total number of Excel errors found\n"
+            "  - total_formulas: Number of formulas in the file\n"
+            "  - error_summary: Breakdown by error type with locations\n"
+            "    - #VALUE!, #DIV/0!, #REF!, #NAME?, #NULL!, #NUM!, #N/A\n"
+        )
+        sys.exit(1)
+
+    filepath = sys.argv[1]
+    timeout = int(sys.argv[2]) if len(sys.argv) > 2 else _DEFAULT_TIMEOUT_SECONDS
+
+    print(json.dumps(recalc(filepath, timeout), indent=2))
+
+
+if __name__ == "__main__":
+    main()