@prismer/runtime 2.0.8 → 2.2.63

package/built-in-skills/office-artifacts/references/docx/scripts/docx_revisions.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+# MIT License. Part of the Hermes docx skill.
+"""Inspect and resolve tracked changes (w:ins / w:del) in a .docx.
+
+Subcommands:
+  list        JSON list of revisions: id, author, date, type, text
+  accept-all  accept every insertion and deletion
+  reject-all  reject every insertion and deletion
+  accept      accept one revision by --id
+  reject      reject one revision by --id
+
+Examples:
+  docx_revisions.py list report.docx
+  docx_revisions.py accept-all report.docx -o accepted.docx
+  docx_revisions.py reject report.docx --id 3 -o out.docx
+
+Semantics (direct XML manipulation, python-docx oxml layer):
+  accept w:ins -> unwrap (keep inserted runs)   reject w:ins -> remove
+  accept w:del -> remove                        reject w:del -> restore
+  (restore = w:delText tags renamed to w:t, wrapper unwrapped)
+
+Covers run-level insertions/deletions anywhere in body, tables (nested
+included), headers and footers. Row/paragraph-mark revisions and format
+changes (w:rPrChange etc.) are reported by docx_read.py --revisions but
+not resolved here.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+from docx import Document
+
+from docx_common import iter_part_roots
+
+W = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+
+
+def q(tag: str) -> str:
+    return f"{{{W}}}{tag}"
+
+
+INS, DEL = q("ins"), q("del")
+
+
+def _iter_revision_elements(doc):
+    """Yield every w:ins / w:del element across body, headers, footers."""
+    for root in iter_part_roots(doc):
+        for el in root.iter(INS, DEL):
+            # Property/row/paragraph-mark revisions are not run wrappers.
+            if el.getparent().tag in {q('p'), INS, DEL, q('hyperlink'), q('sdtContent')}:
+                yield el
+
+
+def _rev_text(el) -> str:
+    tag = q("delText") if el.tag == DEL else q("t")
+    return "".join(t.text or "" for t in el.iter(tag))
+
+
+def _rev_record(el) -> dict:
+    return {
+        "id": el.get(q("id")),
+        "author": el.get(q("author")),
+        "date": el.get(q("date")),
+        "type": "insertion" if el.tag == INS else "deletion",
+        "text": _rev_text(el),
+    }
+
+
+def _unwrap(el) -> None:
+    """Replace `el` with its children, keeping document order."""
+    parent = el.getparent()
+    idx = list(parent).index(el)
+    for child in list(el):
+        parent.insert(idx, child)
+        idx += 1
+    parent.remove(el)
+
+
+def _apply(el, accept: bool) -> None:
+    if el.getparent() is None:  # already detached via an outer wrapper
+        return
+    if el.tag == INS:
+        if accept:
+            _unwrap(el)
+        else:
+            el.getparent().remove(el)
+    else:  # w:del
+        if accept:
+            el.getparent().remove(el)
+        else:
+            for dt in list(el.iter(q("delText"))):
+                dt.tag = q("t")
+            _unwrap(el)
+
+
+def resolve(doc, accept: bool, rev_id: str | None = None) -> int:
+    targets = [el for el in _iter_revision_elements(doc)
+               if rev_id is None or el.get(q("id")) == rev_id]
+    for el in targets:
+        _apply(el, accept)
+    return len(targets)
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(
+        description="List, accept, or reject tracked changes in a .docx.")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+
+    def common(p, out=True):
+        p.add_argument("path", help="input .docx")
+        if out:
+            p.add_argument("-o", "--output",
+                           help="output path (default: overwrite input)")
+
+    common(sub.add_parser("list", help="list revisions as JSON"), out=False)
+    common(sub.add_parser("accept-all", help="accept every revision"))
+    common(sub.add_parser("reject-all", help="reject every revision"))
+    for name in ("accept", "reject"):
+        p = sub.add_parser(name, help=f"{name} one revision by id")
+        common(p)
+        p.add_argument("--id", required=True, help="revision id (w:id)")
+
+    args = ap.parse_args()
+    doc = Document(args.path)
+
+    if args.cmd == "list":
+        revs = [_rev_record(el) for el in _iter_revision_elements(doc)]
+        print(json.dumps({"ok": True, "revisions": revs}, ensure_ascii=False))
+        return 0
+
+    accept = args.cmd in ("accept-all", "accept")
+    rev_id = getattr(args, "id", None)
+    n = resolve(doc, accept, rev_id)
+    if rev_id is not None and n == 0:
+        print(json.dumps({"ok": False,
+                          "error": f"no revision with id {rev_id}"}))
+        return 1
+    out = args.output or args.path
+    doc.save(out)
+    print(json.dumps({"ok": True, "output": out, "resolved": n,
+                      "action": "accept" if accept else "reject"},
+                     ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/built-in-skills/office-artifacts/references/docx/scripts/docx_template.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+# MIT License. Part of the Hermes docx skill.
+"""Fill {{placeholder}} tokens in a .docx from a JSON mapping.
+
+Tokens are replaced everywhere: body paragraphs, tables (including nested
+tables), headers and footers. Run formatting is preserved; tokens split
+across runs are handled.
+
+Usage:
+  docx_template.py template.docx values.json output.docx
+  docx_template.py template.docx values.json output.docx --strict
+
+values.json: {"name": "Ada", "date": "2026-01-01"}  fills {{name}}, {{date}}.
+With --strict, exits 1 if any {{token}} remains unfilled after processing.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+
+from docx import Document
+
+from docx_common import iter_all_paragraphs, replace_in_paragraph
+
+TOKEN_RE = re.compile(r"\{\{\s*([A-Za-z0-9_.-]+)\s*\}\}")
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(
+        description="Fill {{token}} placeholders in a .docx from JSON.")
+    ap.add_argument("template", help="input .docx with {{tokens}}")
+    ap.add_argument("values", help="JSON file of token -> value")
+    ap.add_argument("output", help="output .docx path")
+    ap.add_argument("--strict", action="store_true",
+                    help="fail if any token remains unfilled")
+    args = ap.parse_args()
+
+    with open(args.values, encoding="utf-8") as f:
+        values = json.load(f)
+
+    doc = Document(args.template)
+    filled = {}
+    for para in iter_all_paragraphs(doc):
+        # Normalize whitespace variants like {{ name }} first.
+        for m in set(TOKEN_RE.findall(para.text)):
+            if m in values:
+                # Replace any spacing variant with canonical token, then fill.
+                for variant in set(
+                        t.group(0) for t in TOKEN_RE.finditer(para.text)
+                        if t.group(1) == m):
+                    n = replace_in_paragraph(para, variant, str(values[m]))
+                    filled[m] = filled.get(m, 0) + n
+
+    remaining = sorted({m for para in iter_all_paragraphs(doc)
+                        for m in TOKEN_RE.findall(para.text)})
+    result = {"ok": True, "output": args.output, "filled": filled,
+              "unfilled_tokens": remaining}
+    if args.strict and remaining:
+        result["ok"] = False
+        print(json.dumps(result, ensure_ascii=False))
+        return 1
+    doc.save(args.output)
+    print(json.dumps(result, ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/built-in-skills/office-artifacts/references/docx/scripts/docx_validate.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+# MIT License. Part of the Hermes docx skill.
+"""Health-check a .docx package and report issues as JSON.
+
+Usage: docx_validate.py file.docx
+
+Checks (health-check tier, NOT full XSD schema validation):
+  - the file is a readable zip and python-docx can open it
+  - required package parts exist ([Content_Types].xml, document.xml)
+  - every relationship in every .rels file resolves to a part in the
+    package (dangling image/hyperlink/etc. rels are reported; external
+    targets such as hyperlinks are skipped)
+  - r:embed / r:id references in document.xml resolve to relationships
+  - embedded images are non-empty and start with known magic bytes
+    (PNG/JPEG/GIF/BMP/TIFF/EMF/WMF/SVG); no PIL required
+  - paragraph and run style ids referenced by the document exist in
+    styles.xml
+
+Output: {"ok": bool, "issues": [{"severity": "error"|"warning", ...}]}
+Exit code 1 when any error-severity issue is found (warnings exit 0).
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import posixpath
+import sys
+import zipfile
+
+from lxml import etree
+
+W = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+R = "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+PR = "http://schemas.openxmlformats.org/package/2006/relationships"
+
+IMAGE_MAGIC = (
+    b"\x89PNG\r\n\x1a\n", b"\xff\xd8\xff", b"GIF87a", b"GIF89a",
+    b"BM", b"II*\x00", b"MM\x00*",
+    b"\x01\x00\x00\x00",              # EMF
+    b"\xd7\xcd\xc6\x9a", b"\x01\x00\x09\x00",  # WMF variants
+    b"<?xml", b"<svg",
+)
+
+
+def _issue(issues, severity, code, detail):
+    issues.append({"severity": severity, "code": code, "detail": detail})
+
+
+def _rel_target(base_part: str, target: str) -> str:
+    base_dir = posixpath.dirname(base_part)
+    return posixpath.normpath(posixpath.join(base_dir, target)).lstrip("/")
+
+
+def validate(path: str) -> dict:
+    issues: list[dict] = []
+
+    try:
+        zf = zipfile.ZipFile(path)
+    except (OSError, zipfile.BadZipFile) as exc:
+        _issue(issues, "error", "not-a-zip", str(exc))
+        return {"ok": False, "issues": issues}
+
+    names = set(zf.namelist())
+    bad = zf.testzip()
+    if bad is not None:
+        _issue(issues, "error", "corrupt-member", f"CRC check failed: {bad}")
+
+    for required in ("[Content_Types].xml", "word/document.xml"):
+        if required not in names:
+            _issue(issues, "error", "missing-part",
+                   f"required part absent: {required}")
+    if issues and any(i["severity"] == "error" for i in issues):
+        return {"ok": False, "issues": issues}
+
+    # --- relationships resolve ------------------------------------------
+    rel_ids_by_source: dict[str, dict] = {}
+    for rels_name in [n for n in names if n.endswith(".rels")]:
+        try:
+            root = etree.fromstring(zf.read(rels_name))
+        except etree.XMLSyntaxError as exc:
+            _issue(issues, "error", "bad-rels-xml", f"{rels_name}: {exc}")
+            continue
+        source_part = ("" if rels_name == "_rels/.rels" else posixpath.normpath(
+            posixpath.join(posixpath.dirname(rels_name), "..",
+                           posixpath.basename(rels_name)[:-5])))
+        ids = {}
+        for rel in root.iter(f"{{{PR}}}Relationship"):
+            rid, target = rel.get("Id"), rel.get("Target", "")
+            mode = rel.get("TargetMode", "Internal")
+            ids[rid] = target
+            if mode == "External":
+                continue
+            resolved = _rel_target(source_part or "x", target)
+            if resolved not in names:
+                _issue(issues, "error", "dangling-rel",
+                       f"{rels_name}: {rid} -> {target} (missing part)")
+        rel_ids_by_source[source_part or "_package"] = ids
+
+    # --- r:id / r:embed references in document.xml -----------------------
+    doc_root = etree.fromstring(zf.read("word/document.xml"))
+    doc_rels = rel_ids_by_source.get("word/document.xml", {})
+    for el in doc_root.iter():
+        for attr in (f"{{{R}}}id", f"{{{R}}}embed", f"{{{R}}}link"):
+            rid = el.get(attr)
+            if rid and rid not in doc_rels:
+                _issue(issues, "error", "unresolved-reference",
+                       f"document.xml references {rid} with no relationship")
+
+    # --- embedded images decode ------------------------------------------
+    for name in [n for n in names if n.startswith("word/media/")]:
+        data = zf.read(name)
+        if not data:
+            _issue(issues, "error", "empty-image", name)
+        elif not any(data.startswith(m) for m in IMAGE_MAGIC):
+            _issue(issues, "warning", "unknown-image-format",
+                   f"{name}: unrecognized magic bytes")
+
+    # --- styles referenced exist ------------------------------------------
+    defined = set()
+    if "word/styles.xml" in names:
+        styles_root = etree.fromstring(zf.read("word/styles.xml"))
+        defined = {s.get(f"{{{W}}}styleId")
+                   for s in styles_root.iter(f"{{{W}}}style")}
+    for tag, attr in ((f"{{{W}}}pStyle", f"{{{W}}}val"),
+                      (f"{{{W}}}rStyle", f"{{{W}}}val"),
+                      (f"{{{W}}}tblStyle", f"{{{W}}}val")):
+        for el in doc_root.iter(tag):
+            sid = el.get(attr)
+            if sid and sid not in defined:
+                _issue(issues, "error", "missing-style",
+                       f"style id referenced but not defined: {sid}")
+
+    # --- python-docx can open it ------------------------------------------
+    try:
+        from docx import Document
+        Document(path)
+    except Exception as exc:  # noqa: BLE001 - triage tool, report anything
+        _issue(issues, "error", "python-docx-open-failed", str(exc))
+
+    ok = not any(i["severity"] == "error" for i in issues)
+    return {"ok": ok, "issues": issues}
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(
+        description="Health-check a .docx (not XSD schema validation).")
+    ap.add_argument("path", help="the .docx file to check")
+    args = ap.parse_args()
+    report = validate(args.path)
+    print(json.dumps(report, ensure_ascii=False))
+    return 0 if report["ok"] else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())