@litfamily/lithermes 1.0.7 → 1.0.9

package/assets/lithermes-plugin/skills/lit-pptx/scripts/embed_fonts.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+"""embed_fonts.py — embed bundled fonts into a .pptx so it renders on machines
+that do not have the fonts installed (self-contained deck).
+
+python-pptx has no font-embedding API, so this post-processes the OOXML package
+directly: it adds /ppt/fonts/*.fntdata parts, a fntdata content-type default,
+presentation relationships, and a <p:embeddedFontLst> in ppt/presentation.xml.
+
+Only families with a bundled OTF are embedded; unknown families without bundled binaries are warned
+about and skipped — never corrupting the file.
+
+Usage:
+    python3 scripts/embed_fonts.py <in.pptx> [<out.pptx>]   # in-place if out omitted
+"""
+import os
+import re
+import sys
+import shutil
+import zipfile
+import tempfile
+import subprocess
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+FONT_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/font"
+
+# A2Z english weight word -> bundled file
+A2Z_WEIGHTS = {
+    "Thin", "ExtraLight", "Light", "Regular", "Medium",
+    "SemiBold", "Bold", "ExtraBold", "Black",
+}
+
+
+def _pretendard(weight):
+    p = os.path.join(ROOT, "pretendard-font", "public", "static", f"PretendardGOV-{weight}.otf")
+    return p if os.path.exists(p) else None
+
+
+def _a2z(weight):
+    p = os.path.join(ROOT, "fonts", "a2z-font", f"A2Z-{weight}.otf")
+    return p if os.path.exists(p) else None
+
+
+def resolve_family(typeface):
+    """Return {slot: otf_path} for a typeface, or {} if no bundled file.
+
+    slot is one of regular/bold/italic/boldItalic (we only use regular/bold).
+    """
+    tf = typeface.strip()
+    if tf == "Pretendard":
+        slots = {}
+        if _pretendard("Regular"):
+            slots["regular"] = _pretendard("Regular")
+        if _pretendard("Bold"):
+            slots["bold"] = _pretendard("Bold")
+        return slots
+    # Per-weight families: "에이투지체 7 Bold", "에이투지체 4 Regular", ...
+    last = tf.split()[-1] if tf.split() else ""
+    if ("에이투지체" in tf or tf.startswith("A2Z")) and last in A2Z_WEIGHTS:
+        f = _a2z(last)
+        return {"regular": f} if f else {}
+    return {}
+
+
+def scan_typefaces(z):
+    faces = set()
+    for n in z.namelist():
+        if n.startswith("ppt/slides/slide") and n.endswith(".xml"):
+            xml = z.read(n).decode("utf-8", "ignore")
+            faces.update(re.findall(r'typeface="([^"]+)"', xml))
+    return faces
+
+
+def embed(in_path, out_path=None):
+    out_path = out_path or in_path
+    with zipfile.ZipFile(in_path) as z:
+        names = z.namelist()
+        data = {n: z.read(n) for n in names}
+        faces = scan_typefaces(z)
+
+    # Build embed plan: family -> {slot: otf_path}
+    plan = {}
+    skipped = []
+    for tf in sorted(faces):
+        slots = resolve_family(tf)
+        if slots:
+            plan[tf] = slots
+        else:
+            skipped.append(tf)
+
+    if not plan:
+        print(f"[embed_fonts] no bundled fonts matched typefaces: {sorted(faces)}")
+        if in_path != out_path:
+            shutil.copyfile(in_path, out_path)
+        return {"embedded": [], "skipped": skipped}
+
+    # Assign part names + relationship ids.
+    rels_xml = data["ppt/_rels/presentation.xml.rels"].decode("utf-8")
+    existing_ids = [int(m) for m in re.findall(r'Id="rId(\d+)"', rels_xml)]
+    next_id = (max(existing_ids) + 1) if existing_ids else 1
+
+    font_parts = []   # (part_name, bytes)
+    new_rels = []     # (rId, target)
+    embedded_lst = []  # xml fragments
+    part_idx = 1
+    embedded_report = []
+
+    for tf, slots in plan.items():
+        slot_xml = []
+        for slot in ("regular", "bold", "italic", "boldItalic"):
+            if slot not in slots:
+                continue
+            part_name = f"ppt/fonts/font{part_idx}.fntdata"
+            part_idx += 1
+            with open(slots[slot], "rb") as fh:
+                font_parts.append((part_name, fh.read()))
+            rid = f"rId{next_id}"
+            next_id += 1
+            new_rels.append((rid, "fonts/" + os.path.basename(part_name)))
+            slot_xml.append(f'<p:{slot} r:id="{rid}"/>')
+            embedded_report.append(f"{tf} [{slot}] <- {os.path.basename(slots[slot])}")
+        embedded_lst.append(
+            f'<p:embeddedFont><p:font typeface="{tf}"/>' + "".join(slot_xml) + "</p:embeddedFont>"
+        )
+
+    # 1) [Content_Types].xml — add fntdata default
+    ct = data["[Content_Types].xml"].decode("utf-8")
+    if 'Extension="fntdata"' not in ct:
+        ct = ct.replace(
+            "</Types>",
+            '<Default Extension="fntdata" ContentType="application/x-fontdata"/></Types>',
+        )
+    data["[Content_Types].xml"] = ct.encode("utf-8")
+
+    # 2) presentation rels — add font relationships
+    rel_frag = "".join(
+        f'<Relationship Id="{rid}" Type="{FONT_REL_TYPE}" Target="{tgt}"/>'
+        for rid, tgt in new_rels
+    )
+    rels_xml = rels_xml.replace("</Relationships>", rel_frag + "</Relationships>")
+    data["ppt/_rels/presentation.xml.rels"] = rels_xml.encode("utf-8")
+
+    # 3) presentation.xml — flags + <p:embeddedFontLst>
+    pres = data["ppt/presentation.xml"].decode("utf-8")
+    # embedTrueTypeFonts + saveSubsetFonts on the root element
+    def _set_attr(xml, attr, value):
+        if re.search(rf'\b{attr}="[^"]*"', xml):
+            return re.sub(rf'\b{attr}="[^"]*"', f'{attr}="{value}"', xml, count=1)
+        # insert into the <p:presentation ...> opening tag
+        return re.sub(r"(<p:presentation\b)", rf'\1 {attr}="{value}"', xml, count=1)
+
+    pres = _set_attr(pres, "embedTrueTypeFonts", "1")
+    pres = _set_attr(pres, "saveSubsetFonts", "0")
+    lst = "<p:embeddedFontLst>" + "".join(embedded_lst) + "</p:embeddedFontLst>"
+    # embeddedFontLst must precede custShowLst/defaultTextStyle (schema order).
+    if "<p:defaultTextStyle" in pres:
+        pres = pres.replace("<p:defaultTextStyle", lst + "<p:defaultTextStyle", 1)
+    else:
+        pres = pres.replace("</p:presentation>", lst + "</p:presentation>", 1)
+    data["ppt/presentation.xml"] = pres.encode("utf-8")
+
+    # 4) write the new package (font parts last)
+    tmp_out = out_path + ".tmp"
+    with zipfile.ZipFile(tmp_out, "w", zipfile.ZIP_DEFLATED) as zout:
+        for n, b in data.items():
+            zout.writestr(n, b)
+        for part_name, b in font_parts:
+            zout.writestr(part_name, b)
+    os.replace(tmp_out, out_path)
+
+    if skipped:
+        print(f"[embed_fonts] WARNING — no bundled font, skipped: {skipped}")
+    print("[embed_fonts] embedded:")
+    for line in embedded_report:
+        print("  " + line)
+
+    _verify(out_path)
+    return {"embedded": embedded_report, "skipped": skipped}
+
+
+def _verify(pptx_path):
+    """Check the final archive and reopen it without an external schema bundle."""
+    from integrity import check_package
+    check_package(pptx_path)
+    print("[embed_fonts] integrity OK (archive, content types, relationships, reopen)")
+
+
+def main(argv):
+    if not argv:
+        print(__doc__)
+        return 1
+    in_path = argv[0]
+    out_path = argv[1] if len(argv) > 1 else None
+    embed(in_path, out_path)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

package/assets/lithermes-plugin/skills/lit-pptx/scripts/integrity.py

@@ -0,0 +1,60 @@
+"""Small OOXML package integrity check owned by the LitHermes deck engine."""
+
+from pathlib import Path, PurePosixPath
+from xml.etree import ElementTree as ET
+from zipfile import ZipFile
+from pptx import Presentation
+
+PKG = "http://schemas.openxmlformats.org/package/2006/relationships"
+CONTENT = "http://schemas.openxmlformats.org/package/2006/content-types"
+
+
+def check_package(filename):
+    path = Path(filename)
+    with ZipFile(path) as archive:
+        names = archive.namelist()
+        if len(names) != len(set(names)) or archive.testzip() is not None:
+            raise ValueError("damaged or duplicate OOXML archive member")
+        members = set(names)
+        if not {"[Content_Types].xml", "_rels/.rels", "ppt/presentation.xml"} <= members:
+            raise ValueError("PowerPoint package is missing core members")
+        types = ET.fromstring(archive.read("[Content_Types].xml"))
+        overrides = {part.attrib.get("PartName", "").lstrip("/") for part in types.findall(f"{{{CONTENT}}}Override")}
+        if "ppt/presentation.xml" not in overrides:
+            raise ValueError("presentation content type is missing")
+        for member in names:
+            part = PurePosixPath(member)
+            if part.is_absolute() or ".." in part.parts:
+                raise ValueError("unsafe OOXML member path")
+            if not member.endswith(".rels"):
+                continue
+            root = ET.fromstring(archive.read(member))
+            owner = PurePosixPath(member).parent.parent
+            for rel in root.findall(f"{{{PKG}}}Relationship"):
+                if rel.attrib.get("TargetMode") == "External":
+                    continue
+                target = rel.attrib.get("Target", "").split("#", 1)[0]
+                if target.startswith("/"):
+                    resolved = target.lstrip("/")
+                else:
+                    stack = list(owner.parts) if member != "_rels/.rels" else []
+                    for segment in PurePosixPath(target).parts:
+                        if segment == "..":
+                            if not stack:
+                                raise ValueError("relationship escapes package")
+                            stack.pop()
+                        elif segment != ".":
+                            stack.append(segment)
+                    resolved = "/".join(stack)
+                if resolved not in members:
+                    raise ValueError(f"broken OOXML relationship: {member} -> {resolved}")
+    deck = Presentation(path)
+    if not deck.slides:
+        raise ValueError("PowerPoint package contains no slides")
+    return {"slides": len(deck.slides), "members": len(names)}
+
+
+if __name__ == "__main__":
+    import json
+    import sys
+    print(json.dumps(check_package(sys.argv[1])))

package/assets/lithermes-plugin/skills/lit-pptx/scripts/inventory.py

@@ -0,0 +1,64 @@
+"""Hermes deck layout inventory for geometry defects in text and pictures."""
+
+import argparse
+import json
+from pathlib import Path
+from pptx import Presentation
+from pptx.enum.shapes import MSO_SHAPE_TYPE
+
+
+def inspect(filename):
+    deck = Presentation(filename)
+    result = {}
+    for number, slide in enumerate(deck.slides, 1):
+        shapes = {}
+        candidates = []
+        for index, shape in enumerate(slide.shapes, 1):
+            bounds = (shape.left, shape.top, shape.left + shape.width, shape.top + shape.height)
+            kind = "picture" if shape.shape_type == MSO_SHAPE_TYPE.PICTURE else "text" if shape.has_text_frame else "shape"
+            record = {"type": kind, "overflow": {}, "overlap": {}}
+            if bounds[0] < -9144 or bounds[1] < -9144 or bounds[2] > deck.slide_width + 9144 or bounds[3] > deck.slide_height + 9144:
+                record["overflow"]["slide"] = True
+            if shape.has_text_frame and shape.text.strip():
+                frame = shape.text_frame
+                content_h = max(1, sum(max(1, p.text.count("\n") + 1) * (max((r.font.size.pt for r in p.runs if r.font.size), default=14) * 1.3) for p in frame.paragraphs))
+                available_h = max(0, (shape.height - frame.margin_top - frame.margin_bottom) / 12700)
+                if content_h > available_h * 1.35:
+                    record["overflow"]["frame"] = True
+            if kind in ("text", "picture"):
+                candidates.append((index, bounds, record))
+            shapes[f"shape-{index}"] = record
+        for index, box, record in candidates:
+            if record["type"] != "text":
+                continue
+            overlaps = []
+            for other_index, other_box, other in candidates:
+                if other_index == index or other["type"] != "picture":
+                    continue
+                area = max(0, min(box[2], other_box[2]) - max(box[0], other_box[0])) * max(0, min(box[3], other_box[3]) - max(box[1], other_box[1]))
+                if area > 0.25 * max(1, (box[2] - box[0]) * (box[3] - box[1])):
+                    overlaps.append(f"shape-{other_index}")
+            if overlaps:
+                record["overlap"]["overlapping_shapes"] = overlaps
+        result[f"slide-{number}"] = shapes
+    return result
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("deck")
+    parser.add_argument("output", nargs="?")
+    parser.add_argument("--issues-only", action="store_true")
+    args = parser.parse_args()
+    report = inspect(args.deck)
+    if args.issues_only:
+        report = {slide: {key: item for key, item in shapes.items() if item["overflow"] or item["overlap"]} for slide, shapes in report.items()}
+    body = json.dumps(report, ensure_ascii=False, indent=2)
+    if args.output:
+        Path(args.output).write_text(body, encoding="utf-8")
+    else:
+        print(body)
+
+
+if __name__ == "__main__":
+    main()