@litfamily/litopencode 1.0.7 → 1.0.9

package/skills/lit-pptx/scripts/craft_extras.py

@@ -0,0 +1,224 @@
+"""Measured OOXML craft checks for the LitOpenCode slide QA gate."""
+
+from __future__ import annotations
+
+import colorsys
+import json
+import re
+from pathlib import Path
+
+from pptx import Presentation
+from pptx.enum.shapes import MSO_SHAPE_TYPE
+from pptx.enum.text import PP_ALIGN
+
+T = json.loads(Path(__file__).with_name("craft-thresholds.json").read_text())
+EMU = 914400
+NUMERIC = re.compile(r"^[\d\s,.%+\-±()$€£¥₩▲▼]+$")
+HANGUL = re.compile(r"[가-힣]")
+EMOJI = re.compile(r"[\U0001F000-\U0001FAFF\u2600-\u27BF]")
+
+
+def _box(shape):
+    return tuple(getattr(shape, key) / EMU for key in ("left", "top", "width", "height"))
+
+
+def _gap(a, b):
+    return max(0, max(a[0], b[0]) - min(a[0] + a[2], b[0] + b[2]),
+               max(a[1], b[1]) - min(a[1] + a[3], b[1] + b[3]))
+
+
+def _contains(outer, inner):
+    return outer[0] <= inner[0] and outer[1] <= inner[1] and outer[0] + outer[2] >= inner[0] + inner[2] and outer[1] + outer[3] >= inner[1] + inner[3]
+
+
+def _fill(shape):
+    try:
+        return tuple(shape.fill.fore_color.rgb) if shape.fill.type is not None else None
+    except (AttributeError, TypeError):
+        return None
+
+
+def _hue(rgb):
+    if rgb is None:
+        return None
+    hue, saturation, lightness = colorsys.rgb_to_hls(*(channel / 255 for channel in rgb))
+    if saturation < T["accentSaturationMin"] or not T["accentLightnessMin"] <= lightness <= T["accentLightnessMax"]:
+        return None
+    return hue * 360
+
+
+def _family_count(hues):
+    families = []
+    for hue in hues:
+        if not any(min(abs(hue - other), 360 - abs(hue - other)) <= T["accentHueBucketDegrees"] for other in families):
+            families.append(hue)
+    return len(families)
+
+
+def _text_size(shape):
+    if not getattr(shape, "has_text_frame", False):
+        return 0
+    return max((run.font.size.pt for paragraph in shape.text_frame.paragraphs for run in paragraph.runs if run.font.size), default=0)
+
+
+def _display(slide):
+    text = [shape for shape in slide.shapes if getattr(shape, "has_text_frame", False) and shape.text.strip()]
+    visual = [shape for shape in slide.shapes if getattr(shape, "has_table", False) or getattr(shape, "has_chart", False)]
+    return bool(text) and max(map(_text_size, text)) >= T["displayPt"] and len(text) <= 2 and not visual
+
+
+def _numeric(text):
+    stripped = re.sub(r"[\s,.%+\-±()$€£¥₩▲▼]", "", text.strip())
+    return bool(stripped) and stripped.isdigit()
+
+
+def _radius(shape):
+    try:
+        return float(shape.adjustments[0]) * min(shape.width, shape.height) / EMU
+    except (AttributeError, IndexError, TypeError, ValueError):
+        return None
+
+
+def _vertical_gaps(top, bottom, boxes):
+    cursor = top
+    gaps = []
+    for _, y, _, height in sorted(boxes, key=lambda box: box[1]):
+        gaps.append(max(0, y - cursor))
+        cursor = max(cursor, y + height)
+    gaps.append(max(0, bottom - cursor))
+    return gaps
+
+
+def analyse(path):
+    deck = Presentation(str(path))
+    canvas = deck.slide_width * deck.slide_height
+    findings = []
+
+    def add(rule, severity, slide, value, threshold, tier="measured", shape=None):
+        findings.append({"rule": rule, "severity": severity, "tier": tier, "slide": slide,
+                         "shape": shape, "value": value, "threshold": threshold})
+
+    for slide_no, slide in enumerate(deck.slides, 1):
+        shapes = [shape for shape in slide.shapes if isinstance(shape.width, int) and isinstance(shape.height, int)]
+        display = _display(slide)
+        hues = []
+        for index, shape in enumerate(shapes, 1):
+            if shape.width * shape.height >= T["fullBleedFraction"] * canvas:
+                continue
+            hue = _hue(_fill(shape))
+            if hue is not None:
+                hues.append(hue)
+            if shape._element.xpath('.//a:glow'):
+                add("OF-107", "HIGH", slide_no, "glow", "none", shape=index)
+            if shape._element.xpath('.//a:rPr/a:gradFill'):
+                add("OF-106", "HIGH", slide_no, "gradient text", "none", shape=index)
+            for bullet in shape._element.xpath('.//a:pPr/a:buChar'):
+                char = bullet.get("char", "")
+                if EMOJI.search(char):
+                    add("OF-108", "HIGH", slide_no, char, "no emoji bullet", shape=index)
+
+            if getattr(shape, "has_text_frame", False) and shape.text.strip():
+                size = _text_size(shape)
+                if not T["captionPt"] < size < T["displayPt"]:
+                    continue
+                chars = len(re.sub(r"\s", "", shape.text))
+                if not chars:
+                    continue
+                usable = max(1, shape.width - shape.text_frame.margin_left - shape.text_frame.margin_right)
+                estimated_width = sum((0.98 if HANGUL.match(char) else 0.56) * size for char in shape.text) / 72
+                lines = max(shape.text.count("\n") + 1, round(estimated_width / max(usable / EMU, .01) + .5))
+                if lines < 2:
+                    continue
+                measure = chars / lines
+                cjk = len(HANGUL.findall(shape.text)) / chars >= T["cjkMajority"]
+                ceiling = T["bodyCjkCharsMax"] if cjk else T["bodyLatinCharsMax"]
+                if measure > ceiling:
+                    add("OF-102", "HIGH", slide_no, round(measure, 1), ceiling, "derived", index)
+                elif lines >= T["bodyNarrowLines"] and measure < T["bodyNarrowChars"]:
+                    add("OF-102", "MEDIUM", slide_no, round(measure, 1), T["bodyNarrowChars"], "derived", index)
+
+            if getattr(shape, "has_table", False):
+                table = shape.table
+                for col in range(len(table.columns)):
+                    cells = [table.cell(row, col) for row in range(1, len(table.rows))]
+                    if len(cells) < 2 or sum(_numeric(cell.text) for cell in cells) / len(cells) < T["numericMajority"]:
+                        continue
+                    for row, cell in enumerate(cells, 2):
+                        if not _numeric(cell.text):
+                            continue
+                        for paragraph in cell.text_frame.paragraphs:
+                            if not paragraph.text.strip():
+                                continue
+                            if paragraph.alignment is None:
+                                add("OF-103", "MEDIUM", slide_no, {"row": row, "col": col + 1, "alignment": None}, "right", "derived", index)
+                            elif paragraph.alignment != PP_ALIGN.RIGHT:
+                                add("OF-103", "HIGH", slide_no, {"row": row, "col": col + 1, "alignment": str(paragraph.alignment)}, "right", shape=index)
+
+        count = _family_count(hues)
+        medium = T["displayAccentMedium"] if display else T["contentAccentMedium"]
+        high = T["displayAccentHigh"] if display else T["contentAccentHigh"]
+        if count >= medium:
+            add("OF-101", "HIGH" if count >= high else "MEDIUM", slide_no, count, {"medium": medium, "high": high})
+
+        rounds = [(index, shape, _box(shape), _radius(shape)) for index, shape in enumerate(shapes, 1) if shape.shape_type == MSO_SHAPE_TYPE.AUTO_SHAPE and "ROUNDED_RECTANGLE" in str(shape.auto_shape_type)]
+        for inner_index, inner, ibox, iradius in rounds:
+            for outer_index, outer, obox, oradius in rounds:
+                if inner is outer or iradius is None or oradius is None or not _contains(obox, ibox):
+                    continue
+                insets = [ibox[0] - obox[0], obox[0] + obox[2] - ibox[0] - ibox[2], ibox[1] - obox[1], obox[1] + obox[3] - ibox[1] - ibox[3]]
+                if max(insets) - min(insets) > T["radiusInsetToleranceIn"] or oradius <= T["outerRadiusMinIn"]:
+                    continue
+                expected = max(0, oradius - sum(insets) / len(insets))
+                if abs(iradius - expected) > T["radiusDifferenceToleranceIn"]:
+                    add("OF-104", "HIGH", slide_no, round(iradius, 3), round(expected, 3), shape=inner_index)
+
+        panels = [(shape, _box(shape)) for shape in shapes if _fill(shape) is not None and .2 < shape.width * shape.height / canvas < T["fullBleedFraction"]]
+        groups = []
+        for panel, pbox in panels:
+            members = [_box(item) for item in shapes if item is not panel and getattr(item, "has_text_frame", False) and item.text.strip() and _contains(pbox, _box(item))]
+            if len(members) >= 2:
+                groups.append((pbox, members))
+        if len(groups) >= 2:
+            intra = max((min(_gap(a, b) for i, a in enumerate(members) for b in members[i + 1:]) for _, members in groups), default=0)
+            inter = min((_gap(a, b) for i, (a, _) in enumerate(groups) for b, _ in groups[i + 1:]), default=0)
+            if intra > 0 and inter < T["groupRatioMin"] * intra:
+                add("OF-105", "MEDIUM", slide_no, round(inter / intra, 2), T["groupRatioMin"])
+
+        if not display:
+            title = max((shape for shape in shapes if getattr(shape, "has_text_frame", False) and shape.text.strip() and _text_size(shape) >= T["displayPt"]), key=_text_size, default=None)
+            top = (title.top + title.height) / EMU + .1 if title else .8
+            bottom = deck.slide_height / EMU - .55
+            content = [_box(shape) for shape in shapes if shape is not title and (getattr(shape, "has_table", False) or getattr(shape, "has_chart", False) or shape.shape_type == MSO_SHAPE_TYPE.PICTURE or (getattr(shape, "has_text_frame", False) and shape.text.strip() and _text_size(shape) > T["captionPt"])) and top <= shape.top / EMU < bottom]
+            if content and bottom > top:
+                gaps = _vertical_gaps(top, bottom, content)
+                fraction = max(gaps) / (bottom - top)
+                if fraction >= T["emptyBandMedium"]:
+                    add("OF-109", "HIGH" if fraction > T["emptyBandHigh"] else "MEDIUM", slide_no, round(fraction, 3), {"medium": T["emptyBandMedium"], "high": T["emptyBandHigh"]})
+
+        card_gaps = []
+        for index, card in enumerate(shapes, 1):
+            if _fill(card) is None or card.width * card.height / canvas >= T["fullBleedFraction"]:
+                continue
+            x, y, width, height = _box(card)
+            if width <= 0 or height <= 0:
+                continue
+            frame = getattr(card, "text_frame", None) if getattr(card, "has_text_frame", False) else None
+            top = y + (frame.margin_top / EMU if frame else 0)
+            bottom = y + height - (frame.margin_bottom / EMU if frame else 0)
+            inner = [(item, _box(item)) for item in shapes if item is not card and _contains((x, y, width, height), _box(item)) and (getattr(item, "has_table", False) or getattr(item, "has_chart", False) or item.shape_type == MSO_SHAPE_TYPE.PICTURE or getattr(item, "has_text_frame", False) and item.text.strip())]
+            if not inner or bottom <= top:
+                continue
+            text_items = [item for item, _ in inner if getattr(item, "has_text_frame", False) and item.text.strip()]
+            visuals = [item for item, _ in inner if getattr(item, "has_table", False) or getattr(item, "has_chart", False) or item.shape_type == MSO_SHAPE_TYPE.PICTURE]
+            if text_items and len(text_items) <= 2 and not visuals and max(map(_text_size, text_items)) >= T["displayPt"]:
+                continue
+            gaps = _vertical_gaps(top, bottom, [box for _, box in inner])
+            card_gaps.append({"index": index, "top": y, "height": height, "head": max(gaps[:-1], default=0) / (bottom - top), "tail": gaps[-1] / (bottom - top)})
+        for card in card_gaps:
+            row = [peer for peer in card_gaps if abs(peer["top"] - card["top"]) <= T["equalRowToleranceIn"] and abs(peer["height"] - card["height"]) <= T["equalRowToleranceIn"]]
+            trailing = min(peer["tail"] for peer in row)
+            fraction = max(card["head"], trailing)
+            if fraction >= T["emptyBandMedium"]:
+                add("OF-109", "HIGH" if fraction > T["emptyBandHigh"] else "MEDIUM", slide_no, round(fraction, 3), {"medium": T["emptyBandMedium"], "high": T["emptyBandHigh"]}, shape=card["index"])
+
+    return {"pass": not any(item["severity"] == "HIGH" for item in findings), "findings": findings}

package/skills/lit-pptx/scripts/embed_fonts.py

@@ -0,0 +1,204 @@
+#!/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 (e.g. a custom
+family, whose binaries are not supplied and are not bundled here) 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"LitOpenCodeSans-{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 == "LitOpenCode Sans":
+        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):
+    """Reopen the deck and check ZIP, content types, and relationships."""
+    res = subprocess.run(
+        [sys.executable, os.path.join(ROOT, "scripts", "check_ooxml.py"), pptx_path],
+        capture_output=True, text=True,
+    )
+    if res.returncode:
+        raise RuntimeError(f"OOXML integrity failed after embedding:\n{res.stdout}\n{res.stderr}")
+    print("[embed_fonts] integrity OK (reopen + ZIP/content-types/relationships)")
+
+
+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/skills/lit-pptx/scripts/layout_inventory.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""Inspect authored slide objects for off-canvas and text-frame overflow.
+
+The report shape is consumed by qa_deck.py. Decorative backgrounds and intentional
+layering are not counted as defects; semantic overlap is checked by that gate.
+"""
+
+import argparse
+import json
+from pathlib import Path
+
+from pptx import Presentation
+from pptx.util import Inches
+
+
+def inspect(path):
+    deck = Presentation(path)
+    report = {}
+    tolerance = Inches(0.04)
+    for slide_number, slide in enumerate(deck.slides, 1):
+        issues = {}
+        for index, shape in enumerate(slide.shapes, 1):
+            if not (shape.has_text_frame or shape.shape_type == 13):
+                continue
+            name = f"shape_{index}"
+            overflow = {}
+            off_slide = (shape.left < -tolerance or shape.top < -tolerance or
+                         shape.left + shape.width > deck.slide_width + tolerance or
+                         shape.top + shape.height > deck.slide_height + tolerance)
+            if off_slide:
+                visible_width = max(0, min(shape.left + shape.width, deck.slide_width) - max(shape.left, 0))
+                visible_height = max(0, min(shape.top + shape.height, deck.slide_height) - max(shape.top, 0))
+                visible_fraction = visible_width * visible_height / max(1, shape.width * shape.height)
+                # The enrolled cover deliberately bleeds decorative pictures beyond
+                # the canvas. Record a partial bleed, but fail a nearly lost picture.
+                if shape.has_text_frame or visible_fraction < 0.5:
+                    overflow["slide"] = "object extends past slide boundary"
+            if shape.has_text_frame and shape.text.strip():
+                frame = shape.text_frame
+                usable_height = max(0, shape.height - frame.margin_top - frame.margin_bottom)
+                usable_width = max(1, shape.width - frame.margin_left - frame.margin_right)
+                estimated = 0
+                for paragraph in frame.paragraphs:
+                    if not paragraph.text.strip():
+                        continue
+                    sizes = [run.font.size.pt for run in paragraph.runs if run.font.size]
+                    size = max(sizes, default=16)
+                    approximate_chars = max(1, usable_width / Inches(size / 72 * 0.52))
+                    line_count = max(1, sum(max(1, -(-len(line) // approximate_chars)) for line in paragraph.text.splitlines()))
+                    estimated += line_count * Inches(size / 72 * 1.15)
+                if estimated > usable_height + Inches(0.08):
+                    overflow["frame"] = "estimated text height exceeds frame"
+            if overflow or off_slide:
+                issues[name] = {"overflow": overflow, **({"off_slide": True} if off_slide else {})}
+        if issues:
+            report[str(slide_number)] = issues
+    return report
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("input", type=Path)
+    parser.add_argument("output", type=Path)
+    parser.add_argument("--issues-only", action="store_true")
+    args = parser.parse_args()
+    args.output.write_text(json.dumps(inspect(args.input), ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()