@litfamily/litclaude 1.0.10 → 1.0.13

package/plugins/litclaude/skills/lit-pptx/scripts/deck_craft.py

@@ -0,0 +1,321 @@
+#!/usr/bin/env python3
+"""deck_craft.py — measurable deck-craft checks for the lit-pptx QA gate.
+
+The layout inventory answers "does anything spill or collide". These checks answer
+"does the deck look finished", with numbers a gate can hold:
+
+  sparse_slide        a content slide whose content fills less than FILL_MIN of the
+                      area under its title (a short table at the top of an empty slide)
+  table_only_deck     three or more content slides, tables on at least 60% of them,
+                      and not one chart in the deck
+  off_slide_shape     a picture or shape that runs past the canvas edge and is not a
+                      full-canvas background
+  stray_box           a large outlined rectangle with no fill and no text in or on it
+  placeholder_text    unfilled blanks: [제품명], [금액], XXX, TBD, ○○, {{…}}
+  long_foreign_note   on a Korean deck, a source line (or any small caption) that is
+                      mostly a long run of Latin text
+
+Each finding carries the slide, the shape and a fix hint. A slide counts as a
+display slide (cover, section, closing) when it holds text at 30 pt or more; display
+slides are exempt from the fill and table checks.
+
+Usage:
+    python3 deck_craft.py deck.pptx          # JSON report; exit 0 always
+"""
+
+from __future__ import annotations
+
+import os as _os
+import sys as _sys
+
+_sys.dont_write_bytecode = True  # the installed skill directory stays read-only
+_sys.path.insert(0, _os.path.join(_os.path.dirname(_os.path.abspath(__file__)), "..", "..", "..", "lib"))
+from office_runtime_bootstrap import ensure_runtime  # noqa: E402
+
+ensure_runtime(["pptx"])
+
+import json  # noqa: E402
+import re  # noqa: E402
+from pathlib import Path  # noqa: E402
+
+from pptx import Presentation  # noqa: E402
+from pptx.enum.shapes import MSO_SHAPE_TYPE  # noqa: E402
+from pptx.util import Emu  # noqa: E402
+
+EMU = 914400.0
+FILL_MIN = 0.45
+DISPLAY_PT = 30.0
+CAPTION_PT = 10.5
+EDGE_TOL = 0.03
+FULL_BLEED = 0.92
+# A bracket with a digit in it is a citation marker ([1], [S3]); a blank has none.
+PLACEHOLDER = re.compile(
+    r"\[(?![^\]\n]*\d)[^\]\n]{1,24}\]|\bX{3,}\b|\bTBD\b|\bTODO\b|○○|OOO|\{\{[^}]*\}\}|_{4,}|＿{2,}|<[^<>\n]{1,20}(?:명|값|금액|날짜|이름)>"
+)
+MARKDOWN_LINK = re.compile(r"\[[^\]]+\]\([^)]+\)")
+HANGUL = re.compile(r"[가-힣]")
+LATIN = re.compile(r"[A-Za-z]")
+
+
+def _box(shape):
+    """(left, top, width, height) in inches; a table's height is the sum of its rows,
+    which renderers grow to, not the frame height a writer declared."""
+    try:
+        if shape.left is None or shape.width is None:
+            return None
+        height = shape.height / EMU
+        if getattr(shape, "has_table", False) and shape.has_table:
+            height = max(height, sum(row.height for row in shape.table.rows) / EMU)
+        return (shape.left / EMU, shape.top / EMU, shape.width / EMU, height)
+    except (ValueError, TypeError):
+        # Writers sometimes emit fractional EMU values python-pptx refuses to parse.
+        return None
+
+
+def _flatten(shapes):
+    """Top-level shapes only; a group counts as one box. Group children sit in the
+    group's own coordinate space, which is not the slide's."""
+    for shape in shapes:
+        yield shape
+
+
+def _max_pt(shape):
+    """Largest font size in the shape: run sizes, then paragraph defaults and end-of-paragraph
+    sizes, then PowerPoint's 18 pt default when a writer set none at all."""
+    if not getattr(shape, "has_text_frame", False) or not shape.has_text_frame:
+        return 0.0
+    sizes = []
+    for element in shape.text_frame._txBody.iter():
+        tag = element.tag.rsplit("}", 1)[-1]
+        if tag in ("rPr", "defRPr", "endParaRPr") and element.get("sz"):
+            try:
+                sizes.append(int(element.get("sz")) / 100.0)
+            except ValueError:
+                pass
+    return max(sizes) if sizes else 18.0
+
+
+def _text(shape):
+    if getattr(shape, "has_text_frame", False) and shape.has_text_frame:
+        return shape.text_frame.text.strip()
+    if getattr(shape, "has_table", False) and shape.has_table:
+        return "\n".join(cell.text for row in shape.table.rows for cell in row.cells)
+    return ""
+
+
+def _is_chart(shape):
+    return getattr(shape, "has_chart", False) and shape.has_chart
+
+
+def _is_table(shape):
+    return getattr(shape, "has_table", False) and shape.has_table
+
+
+def _descr(shape):
+    element = shape._element
+    for tag in element.iter():
+        if tag.tag.endswith("}cNvPr"):
+            return (tag.get("descr") or "") + " " + (tag.get("name") or "")
+    return ""
+
+
+def _decorative_picture(shape, page_area):
+    box = _box(shape)
+    if box is None:
+        return True
+    if box[2] * box[3] >= FULL_BLEED * page_area:
+        return True
+    return bool(re.search(r"circle-|template-image|deco", _descr(shape), re.I))
+
+
+def _filled(shape):
+    try:
+        return shape.fill.type is not None and shape.fill.type != 5  # 5 = background
+    except (AttributeError, TypeError):
+        return False
+
+
+def _outlined(shape):
+    line = shape._element.find(".//{http://schemas.openxmlformats.org/drawingml/2006/main}ln")
+    if line is None:
+        return False
+    if line.find("{http://schemas.openxmlformats.org/drawingml/2006/main}noFill") is not None:
+        return False
+    return len(line) > 0 or line.get("w") is not None
+
+
+def _contains(outer, inner, tol=0.05):
+    return (inner[0] >= outer[0] - tol and inner[1] >= outer[1] - tol
+            and inner[0] + inner[2] <= outer[0] + outer[2] + tol and inner[1] + inner[3] <= outer[1] + outer[3] + tol)
+
+
+def slide_layout(shapes, W, H, page_area):
+    """The slide's display flag, title, content area and content boxes, shared by the craft
+    checks here and in craft_extras.py so both judge the same region."""
+    texts = [(s, _text(s)) for s in shapes]
+    # Cover, section and closing slides: display-size type, no data visual, and at
+    # most two headline-sized lines. A KPI slide has several large numbers and is content.
+    has_visual = any(_is_table(s) or _is_chart(s) or (s.shape_type == MSO_SHAPE_TYPE.PICTURE and not _decorative_picture(s, page_area))
+                     for s in shapes)
+    large = [s for s, t in texts if t and _max_pt(s) >= 18]
+    display = (any(_max_pt(s) >= DISPLAY_PT for s, t in texts if t) and not has_visual and len(large) <= 2)
+
+    # Title: the largest text near the top.
+    tops = [(s, _max_pt(s)) for s, t in texts if t and _box(s) and _box(s)[1] < H * 0.25]
+    title = max(tops, key=lambda item: item[1])[0] if tops else None
+    title_bottom = (_box(title)[1] + _box(title)[3]) if title is not None else H * 0.2
+    area = (0.5, title_bottom + 0.1, W - 1.0, max(0.1, H - 0.55 - title_bottom - 0.1))
+
+    visuals = []
+    boxes = []
+    for shape, text in texts:
+        if shape is title:
+            continue
+        box = _box(shape)
+        if box is None:
+            continue
+        if shape.shape_type == MSO_SHAPE_TYPE.PICTURE:
+            if _decorative_picture(shape, page_area):
+                continue
+            visuals.append("figure")
+        elif _is_chart(shape):
+            visuals.append("chart")
+        elif _is_table(shape):
+            visuals.append("table")
+        elif text:
+            if _max_pt(shape) <= CAPTION_PT:
+                continue
+        elif shape.shape_type in (MSO_SHAPE_TYPE.AUTO_SHAPE, MSO_SHAPE_TYPE.GROUP) and box[2] * box[3] >= 0.5 and (
+                shape.shape_type == MSO_SHAPE_TYPE.GROUP or _filled(shape)):
+            if box[2] * box[3] < FULL_BLEED * page_area:
+                visuals.append("card")
+        else:
+            continue
+        boxes.append(box)
+    return {"display": display, "title": title, "area": area, "boxes": boxes, "visuals": visuals}
+
+
+def analyse(path: Path) -> dict:
+    prs = Presentation(str(path))
+    W, H = prs.slide_width / EMU, prs.slide_height / EMU
+    page_area = W * H
+    findings: list[dict] = []
+    all_text = []
+    per_slide = []
+
+    for number, slide in enumerate(prs.slides, start=1):
+        # The engine's sample-data tag is a label on every slide, not slide content.
+        shapes = [s for s in _flatten(slide.shapes) if not s.name.startswith("lit-notice")]
+        texts = [(s, _text(s)) for s in shapes]
+        all_text.extend(t for _, t in texts if t)
+        layout = slide_layout(shapes, W, H, page_area)
+        display = layout["display"]
+
+        # Placeholder blanks anywhere, display slides included.
+        for shape, text in texts:
+            cleaned = MARKDOWN_LINK.sub(" ", text)
+            hit = PLACEHOLDER.search(cleaned)
+            if hit:
+                findings.append({"check": "placeholder_text", "slide": number, "shape": shape.name,
+                                 "detail": hit.group(0),
+                                 "hint": "Fill the blank with a realistic value and label it as an example or assumption."})
+
+        # Anything past the canvas edge that is not a full-canvas background.
+        for shape in shapes:
+            box = _box(shape)
+            if box is None or box[2] * box[3] >= FULL_BLEED * page_area:
+                continue
+            if box[0] < -EDGE_TOL or box[1] < -EDGE_TOL or box[0] + box[2] > W + EDGE_TOL or box[1] + box[3] > H + EDGE_TOL:
+                findings.append({"check": "off_slide_shape", "slide": number, "shape": shape.name,
+                                 "detail": [round(v, 2) for v in box],
+                                 "hint": "Keep decorations inside the canvas; a cropped shape reads as a layout error."})
+
+        # Large outlined empty rectangles.
+        content_boxes = [_box(s) for s, t in texts if (t or _is_chart(s) or s.shape_type == MSO_SHAPE_TYPE.PICTURE) and _box(s)]
+        for shape in shapes:
+            if shape.shape_type != MSO_SHAPE_TYPE.AUTO_SHAPE or _text(shape):
+                continue
+            box = _box(shape)
+            if box is None or box[2] * box[3] < 1.0:
+                continue
+            try:
+                geometry = shape.auto_shape_type
+                rectangular = "RECTANGLE" in str(geometry)
+            except (NotImplementedError, ValueError):
+                rectangular = False
+            if not rectangular or _filled(shape) or not _outlined(shape):
+                continue
+            if any(_contains(box, inner) for inner in content_boxes if inner != box):
+                continue
+            findings.append({"check": "stray_box", "slide": number, "shape": shape.name,
+                             "detail": [round(v, 2) for v in box],
+                             "hint": "Remove the empty frame or put the message inside a tinted callout."})
+
+        if display:
+            per_slide.append({"slide": number, "display": True})
+            continue
+
+        title, area, boxes, visuals = layout["title"], layout["area"], layout["boxes"], layout["visuals"]
+
+        if not boxes and title is not None and len(_text(title)) <= 30:
+            # Only a short line on the slide: a closing or "Q&A" slide, not a sparse one.
+            per_slide.append({"slide": number, "display": True})
+            continue
+        if boxes:
+            left = max(area[0], min(b[0] for b in boxes))
+            top = max(area[1], min(b[1] for b in boxes))
+            right = min(area[0] + area[2], max(b[0] + b[2] for b in boxes))
+            bottom = min(area[1] + area[3], max(b[1] + b[3] for b in boxes))
+            fill = max(0.0, right - left) * max(0.0, bottom - top) / (area[2] * area[3])
+        else:
+            fill = 0.0
+        cards = visuals.count("card")
+        primary = ("chart" if "chart" in visuals else "figure" if "figure" in visuals else "table" if "table" in visuals
+                   else "cards" if cards >= 2 else "text")
+        per_slide.append({"slide": number, "display": False, "fill": round(fill, 2), "primary": primary})
+        if fill < FILL_MIN:
+            findings.append({"check": "sparse_slide", "slide": number, "shape": None, "detail": round(fill, 2),
+                             "hint": f"Content fills {fill:.0%} of the area under the title (floor {FILL_MIN:.0%}): "
+                                     "give the message a visual that uses the space (chart, KPI cards, a fuller table "
+                                     "with its takeaway), or merge the slide with its neighbour."})
+
+    content = [s for s in per_slide if not s["display"]]
+    tables = sum(1 for s in content if s["primary"] == "table")
+    charts = sum(1 for s in content if s["primary"] == "chart")
+    if len(content) >= 3 and charts == 0 and tables >= 2 and tables >= 0.6 * len(content):
+        findings.append({"check": "table_only_deck", "slide": None, "shape": None,
+                         "detail": f"{tables} of {len(content)} content slides are tables and none is a chart",
+                         "hint": "Numeric series belong in native charts (::: chart) and headline numbers in KPI "
+                                 "cards; keep tables for lookups a reader scans."})
+
+    corpus = "\n".join(all_text)
+    # One Hangul syllable carries about as much as two or three Latin letters.
+    korean = 2.5 * len(HANGUL.findall(corpus)) > len(LATIN.findall(corpus))
+    if korean:
+        for number, slide in enumerate(prs.slides, start=1):
+            for shape in _flatten(slide.shapes):
+                text = _text(shape)
+                if not text:
+                    continue
+                source_line = bool(re.match(r"\s*(?:sources?|출처|자료)\b", text, re.I))
+                if _max_pt(shape) > CAPTION_PT + 0.5 and not source_line:
+                    continue
+                latin, hangul = len(LATIN.findall(text)), len(HANGUL.findall(text))
+                if latin >= 60 and latin / max(1, latin + hangul) > 0.7:
+                    findings.append({"check": "long_foreign_note", "slide": number, "shape": shape.name,
+                                     "detail": text[:80],
+                                     "hint": "On a Korean deck keep sources short and in Korean (기관, 문서명, 연도)."})
+
+    return {"file": str(path), "pass": not findings, "slides": per_slide, "findings": findings}
+
+
+def main(argv: list[str]) -> int:
+    if not argv:
+        print(__doc__)
+        return 2
+    print(json.dumps(analyse(Path(argv[0])), ensure_ascii=False, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(_sys.argv[1:]))

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

@@ -0,0 +1,215 @@
+#!/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 (fonts/pretendard, fonts/a2z) are embedded; unknown families (fonts a learned
+template names but this skill does not bundle) 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 as _os
+import sys as _sys
+
+_sys.dont_write_bytecode = True  # the installed skill directory stays read-only
+_sys.path.insert(0, _os.path.join(_os.path.dirname(_os.path.abspath(__file__)), "..", "..", "..", "lib"))
+from office_runtime_bootstrap import ensure_runtime  # noqa: E402
+
+ensure_runtime(["pptx"])
+
+import os
+import re
+import sys
+import shutil
+import zipfile
+
+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, "fonts", "pretendard", f"Pretendard-{weight}.otf")
+    return p if os.path.exists(p) else None
+
+
+def _a2z(weight):
+    p = os.path.join(ROOT, "fonts", "a2z", 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):
+    """Integrity gate: the package check in plugins/litclaude/lib/ooxml_integrity.py
+    (zip, content types, well-formed XML, relationship targets, embedded font
+    parts) plus a python-pptx reopen."""
+    from pathlib import Path
+    from ooxml_integrity import check_package
+
+    report = check_package(Path(pptx_path))
+    if not report["pass"]:
+        raise RuntimeError(
+            "OOXML integrity failed after embedding:\n  " + "\n  ".join(report["problems"])
+        )
+    print("[embed_fonts] integrity OK (package structure + python-pptx 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/plugins/litclaude/skills/lit-pptx/scripts/forbidden-terms.json

@@ -0,0 +1,55 @@
+{
+  "case_insensitive": true,
+  "whole_word": false,
+  "terms": [
+    "click to add title",
+    "click to add subtitle",
+    "click to add text",
+    "content goes here",
+    "your logo",
+    "placeholder",
+    "lorem ipsum",
+    "tbd",
+    "fixme",
+    "todo",
+    "본 슬라이드는",
+    "슬라이드 7은",
+    "최종본에서 걸러냈다",
+    "[자사 확인 필요]",
+    "[출처 확인 필요]",
+    "[작성 중]"
+  ],
+  "soft_terms": [
+    "revolutionary",
+    "cutting-edge",
+    "seamless",
+    "seamlessly",
+    "innovative",
+    "world-class",
+    "best-in-class",
+    "transformative",
+    "next-generation",
+    "game-changing",
+    "state-of-the-art",
+    "AI-powered",
+    "AI-generated",
+    "as an AI",
+    "unlock",
+    "empower",
+    "synergy",
+    "holistic",
+    "paradigm shift",
+    "frictionless",
+    "없다는 것이 발견",
+    "판이 굳었다",
+    "전제로 깐다",
+    "닫아야 할 게이트",
+    "역전 금지",
+    "논문이 없다",
+    "RAM",
+    "FTO",
+    "CNKI",
+    "코퍼스",
+    "전이원"
+  ]
+}