@litfamily/lithermes 1.0.8 → 1.0.10

package/assets/lithermes-plugin/core_routing.py

@@ -35,7 +35,10 @@ SKILL_RENAME_ALIASES = {
     "git-master": "lit-commit",
     "remove-ai-slops": "lit-burnoff",
     "ai-slop-remover": "lit-burnoff-file",
-    "korean-ai-slop-remover": "lit-korean",
+    "lit-korean": "lit-humanizer",
+    "text-naturalization": "lit-humanizer",
+    "text-neutralization": "lit-humanizer",
+    "korean-ai-slop-remover": "lit-humanizer",
     "programming": "lit-code",
 }
 _RENAMED_ROUTE_ALIASES = {**SKILL_RENAME_ALIASES, "teammode": "lit-team"}
@@ -55,12 +58,16 @@ def _renamed_skill_route(text: str, visible: str, source: str, offset: int = 0)
         match = re.match(rf"^\s*{re.escape(word)}(?![\w-])(?P<rest>.*)$", text, re.IGNORECASE | re.DOTALL)
         if match is not None:
             rest = match.group("rest").strip()
-            if name == "lit-korean":
+            if name == "lit-humanizer":
                 # Only the trigger is parsed as instructions. Retain code spans
                 # and fences in the original prose for the escaped content path.
                 rest = source[offset + match.start("rest"):].strip()
             return NaturalLitRoute(
-                mode={"lit-korean": "korean-prose-cleanup", "lit-team": "kanban-team"}.get(name, name),
+                mode=(
+                    "korean-prose-cleanup" if name == "lit-humanizer" and word in SKILL_RENAME_ALIASES
+                    else "kanban-team" if name == "lit-team"
+                    else name
+                ),
                 objective=_clamp_task(rest),
                 visible_message=visible,
                 deprecation_note=skill_rename_note(word) if word in _RENAMED_ROUTE_ALIASES else "",
@@ -80,6 +87,8 @@ _BARE_SKILL_PREFIXES = (
     ("wikify", "wikify"),
     ("litresearch", "litresearch"),
     ("lit-comprehend", "lit-comprehend"),
+    ("humanizer", "lit-humanizer"),
+    ("lit-humanizer", "lit-humanizer"),
     ("comprehend", "lit-comprehend"),
     ("comment-checker", "comment-checker"),
     ("lsp-setup", "lsp-setup"),
@@ -92,6 +101,10 @@ _BARE_SKILL_PREFIXES = (
     # after case and stays. Both ids are hyphenated compounds, so neither can be
     # reached by an ordinary English sentence; see the token-shape note below.
     ("frontend-ui-ux", "frontend-ui-ux"),
+    ("lit-diagram-drawer", "lit-diagram-drawer"),
+    ("lit-pptx", "lit-pptx"),
+    ("lit-docx", "lit-docx"),
+    ("lit-typographic-motion", "lit-typographic-motion"),
     ("readme-studio", "readme-studio"),
     ("visual-qa", "visual-qa"),
     ("structural-search", "structural-search"),
@@ -134,6 +147,10 @@ _LIT_SKILL_SUFFIXES = (
     ("slop", "lit-burnoff"),
     ("rules", "rules"),
     ("frontend-ui-ux", "frontend-ui-ux"),
+    ("lit-diagram-drawer", "lit-diagram-drawer"),
+    ("lit-pptx", "lit-pptx"),
+    ("lit-docx", "lit-docx"),
+    ("lit-typographic-motion", "lit-typographic-motion"),
     ("readme-studio", "readme-studio"),
     ("visual-qa", "visual-qa"),
     # `design` is safe HERE and only here: the user already typed `lit`, so intent is
@@ -173,7 +190,7 @@ UI_INTENT_VERBS = (
 # as UI surfaces in a sentence but are not path/diff signals.
 UI_INTENT_PROSE_NOUNS = (
     "user interface", "screen", "page", "layout", "modal", "navbar", "sidebar",
-    "stylesheet", "css", "design system", "landing page", "theme", "styling",
+    "stylesheet", "css", "design system", "landing page", "theme", "styling", "web app",
 )
 UI_INTENT_NOUNS = tuple(UI_SURFACE_NOUNS) + UI_INTENT_PROSE_NOUNS
 
@@ -226,7 +243,7 @@ UI_INTENT_NOUNS_KO = (
     # NOTE: UI / UX deliberately absent — they live in UI_INTENT_NOUNS and the
     # shared boundary below already matches them next to a Korean particle.
     # Duplicating them here is the drift hazard this module already fought once.
-    "화면", "페이지", "레이아웃", "대시보드", "사이드바", "모달", "컴포넌트",
+    "화면", "페이지", "레이아웃", "대시보드", "사이드바", "모달", "컴포넌트", "웹앱", r"웹\s+앱",
     "프론트엔드", "스타일시트", "내비게이션", "네비게이션",
     # 버튼 is the only component-level noun here and the only one with a MEASURED
     # containment leak: "버튼식 잠금장치 만들어줘" (a physical push-button lock) fired.
@@ -440,6 +457,125 @@ def detect_ui_intent(text: str) -> bool:
     return has_verb and has_noun
 
 
+def detect_ui_mode(text: str) -> str | None:
+    """Classify a UI request by its requested action; None means another domain."""
+    value = str(text or "")
+    has_ui = bool(_UI_INTENT_NOUN_RE.search(value)) or bool(_UI_INTENT_NOUN_KO_RE.search(value))
+    if not has_ui:
+        return None
+    if re.search(r"(?:^|\W)(?:slides?|deck|pptx?|presentation|video)(?:\W|$)|발표|슬라이드|영상", value, re.IGNORECASE):
+        return None
+    if re.search(r"\b(?:audit|review(?: this page)? read.only|just check|don't fix)\b|점검|검토만|수정.{0,8}하지", value, re.IGNORECASE):
+        if not re.search(r"(?<!don't )\bfix\b|고쳐|수정해", value, re.IGNORECASE):
+            return "audit"
+    if re.search(r"\b(?:harden|stress.test|hold up under|robust to)\b|튼튼하게|견고하게", value, re.IGNORECASE):
+        return "harden"
+    if re.search(r"\b(?:polish|clean up the styling|tighten up)\b|다듬", value, re.IGNORECASE):
+        if not re.search(r"\b(?:redesign|brand.new|add a|create|build|implement)\b|새로|추가해|다시 짜", value, re.IGNORECASE):
+            return "polish"
+    return "build" if detect_ui_intent(value) else None
+
+
+# MO-C-18..20: the motion trigger is a creation verb plus a compound
+# motion-video noun, or plus a bare video noun, with none of five exclusions.
+# The verb half reuses this product's office/UI creation verbs and adds a small
+# motion-specific set they lack (제작, 뽑-, 렌더, render, produce, animate).
+# Bare 모션/motion and 인트로/intro are never nouns here; they count only
+# inside a compound or next to a video noun. Exclusions route to the skill
+# that owns the request instead of silently falling to litwork.
+MOTION_MODE = "lit-typographic-motion"
+_MOTION_VERB = re.compile(
+    r"만들|작성|제작|생성|디자인|뽑|렌더|"
+    r"(?<![A-Za-z])(?:make|create|design|build|generate|render|produce|animate)(?![A-Za-z])",
+    re.IGNORECASE,
+)
+_MOTION_COMPOUND = re.compile(
+    r"모션\s*그래픽|타이포\s*모션|키네틱\s*타이포(?:그래피)?|타이포그래피\s*영상|가사\s*영상|리릭\s*(?:비디오|영상)|"
+    r"뮤직\s*비디오|오프닝\s*타이틀|타이틀\s*시퀀스|"
+    r"(?<![A-Za-z])(?:motion\s+graphics?|kinetic\s+type(?:graphy)?|typographic\s+motion|lyric\s+videos?|"
+    r"music\s+videos?|title\s+sequences?|opening\s+titles?)(?![A-Za-z])",
+    re.IGNORECASE,
+)
+_MOTION_VIDEO = re.compile(r"영상|비디오|(?<![A-Za-z])(?:videos?|clips?)(?![A-Za-z])", re.IGNORECASE)
+_MOTION_BARE = re.compile(r"모션|(?<![A-Za-z])motion(?![A-Za-z])", re.IGNORECASE)
+# (i) editing or captioning existing footage
+_MOTION_EDIT = re.compile(
+    r"편집|자막|색\s*보정|트리밍|잘라|자르|촬영본|기존\s*(?:영상|비디오|클립)|"
+    r"(?<![A-Za-z])(?:edit|editing|captions?|subtitles?|trim|crop|colou?r[-\s]?grad(?:e|ing)|footage|existing)(?![A-Za-z])",
+    re.IGNORECASE,
+)
+# (ii) a UI or web container with an embed/insert verb or a background video
+_MOTION_UI_CONTAINER = re.compile(
+    r"페이지|웹\s*사이트|랜딩|화면|컴포넌트|버튼|"
+    r"(?<![A-Za-z])(?:pages?|websites?|landing|screens?|components?|buttons?)(?![A-Za-z])",
+    re.IGNORECASE,
+)
+_MOTION_EMBED = re.compile(r"넣|삽입|(?<![A-Za-z])(?:embed\w*|insert\w*)(?![A-Za-z])", re.IGNORECASE)
+_MOTION_BACKGROUND = re.compile(r"배경\s*영상|(?<![A-Za-z])background\s+videos?(?![A-Za-z])", re.IGNORECASE)
+# (iii) an office deliverable other than a bare 발표, with an embed/insert verb
+_MOTION_SLIDES = re.compile(r"발표\s*자료|슬라이드|피피티|덱|(?<![A-Za-z])(?:pptx?|slides?|decks?)(?![A-Za-z])", re.IGNORECASE)
+_MOTION_DOCS = re.compile(r"보고서|문서|(?<![A-Za-z])(?:reports?|documents?)(?![A-Za-z])", re.IGNORECASE)
+# (iv) a text or image artifact about a video
+_MOTION_ABOUT = re.compile(
+    r"스크립트|대본|썸네일|요약|기획안|스토리보드|"
+    r"(?<![A-Za-z])(?:scripts?|transcripts?|thumbnails?|summary|summari[sz]e|storyboards?)(?![A-Za-z])",
+    re.IGNORECASE,
+)
+
+
+def motion_route(text: str) -> str | None:
+    """Return the motion mode, the owner an exclusion names, or None."""
+    value = str(text or "")
+    videoish = _MOTION_COMPOUND.search(value) or _MOTION_VIDEO.search(value)
+    if videoish:
+        if _MOTION_EMBED.search(value) and (_MOTION_SLIDES.search(value) or _MOTION_DOCS.search(value)):
+            return "lit-pptx" if _MOTION_SLIDES.search(value) else "lit-docx"
+        if _MOTION_UI_CONTAINER.search(value) and (_MOTION_EMBED.search(value) or _MOTION_BACKGROUND.search(value)):
+            return "frontend-ui-ux"
+        if _MOTION_EDIT.search(value) or _MOTION_ABOUT.search(value):
+            return None
+        return MOTION_MODE if _MOTION_VERB.search(value) else None
+    ui_surface = _MOTION_UI_CONTAINER.search(value) or _UI_INTENT_NOUN_RE.search(value) or _UI_INTENT_NOUN_KO_RE.search(value)
+    if _MOTION_BARE.search(value) and ui_surface:
+        return "frontend-ui-ux"
+    return None
+
+
+def detect_motion_video_intent(text: str) -> bool:
+    return motion_route(text) == MOTION_MODE
+
+
+# The optional type-led hint. It only ever names a cue that points toward the
+# type path (a type compound, an explicit kinetic-type or lyric ask, or a quoted
+# span of two or more words); it never says the reverse. Finding a quote is cue
+# detection: the quoted text is reported as a short label, never followed.
+_MOTION_TYPE_CUE = re.compile(
+    r"타이포\s*모션|키네틱\s*타이포(?:그래피)?|타이포(?:그래피)?\s*영상|가사\s*영상|리릭\s*(?:비디오|영상)|"
+    r"타이틀\s*시퀀스|오프닝\s*타이틀|"
+    r"(?<![A-Za-z])(?:kinetic\s+type(?:graphy)?|typographic\s+motion|typography\s+videos?|lyric\s+videos?|"
+    r"title\s+sequences?|opening\s+titles?)(?![A-Za-z])",
+    re.IGNORECASE,
+)
+_MOTION_QUOTED = re.compile(
+    r'"([^"\n]{2,200})"|“([^”\n]{2,200})”|(?<![A-Za-z])\'([^\'\n]{2,200})\'(?![A-Za-z])|「([^」\n]{2,200})」'
+)
+
+
+def motion_cue(text: str) -> str | None:
+    """Return a short label for a type-led cue in the request, or None."""
+    value = str(text or "")
+    compound = _MOTION_TYPE_CUE.search(value)
+    if compound:
+        phrase = re.sub(r"\s+", " ", compound.group(0))
+        return f"type compound ({phrase})"
+    for match in _MOTION_QUOTED.finditer(value):
+        span = next(group for group in match.groups() if group is not None).strip()
+        if len(span.split()) >= 2:
+            label = span if len(span) <= 24 else span[:23] + "…"
+            return f"quoted span ({label})"
+    return None
+
+
 _RUN_CONTEXT_TASK_PATTERN = re.compile(r"^task:\s*(?P<task>.+?)\s*$", re.MULTILINE)
 
 _FENCED_CODE_RE = re.compile(r"(^|\n)(`{3,}|~{3,})[^\n]*\n.*?(?:\n\2(?=\n|$)|$)", re.DOTALL)
@@ -491,6 +627,39 @@ def _normalized_exact_phrase(text: str) -> str:
     return re.sub(r"\s+", " ", text.strip()).lower()
 
 
+def _bare_lit_mode(objective: str) -> str:
+    prose = re.sub(r"(?m)^\s*#{1,6}\s+.*$", "", objective).strip()
+    first = re.split(r"[\n.!?]", prose, maxsplit=1)[0]
+    slide = re.search(r"발표자료|발표|슬라이드|피피티|(?:^|[^A-Za-z])(?:slides?|deck|presentation|pptx?)(?![A-Za-z])", first, re.IGNORECASE)
+    document = re.search(r"보고서|리포트|기획서|제안서|문서|워드|(?:^|[^A-Za-z])(?:report|docx?|word)(?![A-Za-z])", first, re.IGNORECASE)
+    authoring = re.search(r"만들|작성|써\s*줘|써줘|제작|생성|정리|(?:^|[^A-Za-z])(?:make|create|write|draft|prepare|build|produce|generate)(?![A-Za-z])", first, re.IGNORECASE)
+    # The motion check runs before the office and UI checks (MO-C-18), so a
+    # video noun beside a bare 발표 or 타이포그래피 still reaches motion.
+    motion = motion_route(first)
+    if motion is not None:
+        return motion
+    if authoring and slide:
+        return "lit-pptx"
+    if authoring and document:
+        return "lit-docx"
+    english = re.match(
+        r"^(?:(?:please|can you|could you)\s+)?(?:draw|create|make|design|render|generate)\s+"
+        r"(?P<lead>.{0,120}?)\b(?:diagram|flowchart|flow chart)\b(?P<tail>.*)",
+        first, re.IGNORECASE,
+    )
+    if english and not re.search(
+        r"\b(?:app|page|dashboard|widget|editor|parser|component|tool|api|test)s?\b",
+        english.group("lead") + " " + english.group("tail"), re.IGNORECASE,
+    ):
+        return "lit-diagram-drawer"
+    if re.search(r"(?:다이어그램|흐름도|구성도).{0,60}(?:그려|그리|만들|생성|작성)", first):
+        if not re.search(r"편집기|파서|위젯|대시보드|테스트", first):
+            return "lit-diagram-drawer"
+    if detect_ui_mode(first) is not None:
+        return "frontend-ui-ux"
+    return "litwork"
+
+
 def detect_lit_mode(message: str) -> NaturalLitRoute | None:
     """Route a natural-language LitHermes activation to a native mode.
 
@@ -526,6 +695,17 @@ def detect_lit_mode(message: str) -> NaturalLitRoute | None:
             blocked=True,
             block_message=block,
         )
+    trailing_lit = re.fullmatch(
+        r"(?s)(?P<objective>.+?)\r?\n[ \t]*\r?\n[ \t]*lit[ \t]*(?:\r?\n)?[ \t]*",
+        visible,
+        re.IGNORECASE,
+    )
+    if trailing_lit is not None:
+        return NaturalLitRoute(
+            mode=_bare_lit_mode(trailing_lit.group("objective")),
+            objective=_clamp_task(trailing_lit.group("objective")),
+            visible_message=visible,
+        )
     for word, mode in _BARE_SKILL_PREFIXES:
         matcher = _after_semantic_family_word if mode in _SEMANTIC_FAMILY_MODES else _after_mode_word
         rest = matcher(visible, word)
@@ -592,18 +772,27 @@ def detect_lit_mode(message: str) -> NaturalLitRoute | None:
             ("review", "review-work"),
             ("research", "litresearch"),
             ("goal", "litgoal"),
-            *_LIT_SKILL_SUFFIXES,
+            *(item for item in _LIT_SKILL_SUFFIXES if item[0] != "design"),
         ):
             matcher = _after_semantic_family_word if mode in _SEMANTIC_FAMILY_MODES else _after_mode_word
             rest = matcher(after, word)
             if rest is not None:
                 return NaturalLitRoute(mode=mode, objective=_clamp_task(rest), visible_message=visible)
-        return NaturalLitRoute(mode="litwork", objective=_clamp_task(after), visible_message=visible)
+
+        # After the named routes and before `design` (which names the UI skill):
+        # "lit design a lyric video" is a film request (MO-C-18).
+        if detect_motion_video_intent(re.split(r"[\n.!?]", after, maxsplit=1)[0]):
+            return NaturalLitRoute(mode=MOTION_MODE, objective=_clamp_task(after), visible_message=visible)
+        rest = _after_mode_word(after, "design")
+        if rest is not None:
+            return NaturalLitRoute(mode="frontend-ui-ux", objective=_clamp_task(rest), visible_message=visible)
+        objective = after or visible[:match.start()].strip()
+        return NaturalLitRoute(mode=_bare_lit_mode(objective), objective=_clamp_task(objective), visible_message=visible)
 
     # Lowest precedence, deliberately: an explicit `lit` token or a named skill
     # always wins. Only when nothing else matched does the UI intent conjunction
     # get a say.
-    if detect_ui_intent(visible):
+    if detect_ui_mode(visible) is not None:
         return NaturalLitRoute(
             mode="frontend-ui-ux", objective=_clamp_task(visible), visible_message=visible
         )