Auto-sync from GitHub Actions

.gitignore

@@ -20,4 +20,4 @@ CLAUDE.md
 docs/
 .*/
 /AGENTS.md
-test/
+tests/

api_fastapi.py

@@ -27,39 +27,30 @@ FastAPI 适配层（可选）。
 from __future__ import annotations
 
 import asyncio
+import re
+from typing import Any
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel, Field
 
 from core.engine import DanbooruTagger
-from core.models import SearchRequest, SearchResponse, TagResult, RelatedTag
+from core.models import SearchRequest, SearchResponse
 import core.counter as counter
 
 
 # ── Pydantic I/O 模型（API 层专用，与 core.models 解耦）──
 
+
 class SearchIn(BaseModel):
     query: str
-    top_k: int = Field(5, ge=1, le=50)
-    limit: int = Field(80, ge=1, le=500)
-    popularity_weight: float = Field(0.15, ge=0.0, le=1.0)
+    search_mode: str = "full_scene"
+    category: str = "all"
     show_nsfw: bool = True
-    use_segmentation: bool = True
-    target_layers: list[str] = ['英文', '中文扩展词', '释义', '中文核心词']
-    target_categories: list[str] = ['General', 'Character', 'Copyright']
-    group_mode: str = "off"
-    max_per_group: int = 2
+    include_wiki: bool = False
 
 
 class TagOut(BaseModel):
     tag: str
     cn_name: str
-    category: str
-    nsfw: str
-    final_score: float
-    semantic_score: float
-    count: int
-    source: str
-    layer: str
     wiki: str = ""
 
 
@@ -67,40 +58,98 @@ class RelatedIn(BaseModel):
     tags: list[str]
     limit: int = Field(50, ge=1, le=200)
     show_nsfw: bool = True
+    include_wiki: bool = False
 
 
 class RelatedTagOut(BaseModel):
     tag: str
     cn_name: str
-    category: str
-    nsfw: str
-    cooc_count: int
-    cooc_score: float
     sources: list[str]
-    post_count: int = 0
     wiki: str = ""
 
 
 class SearchOut(BaseModel):
-    tags_all: str
-    tags_sfw: str
+    prompt: str
     results: list[TagOut]
     keywords: list[str]
+    hint: str | None = None
 
 
 class ArtistIn(BaseModel):
     tags: list[str]
     limit: int = Field(30, ge=1, le=100)
     min_cooc: int = Field(3, ge=1, le=100)
+    show_nsfw: bool = True
 
 
 class ArtistOut(BaseModel):
     artist: str
-    score: float
     cooc_count: int
     post_count: int
     sources: list[str]
-    hit_count: int
+    top_tags: list[str]
+
+
+_SEARCH_MODE_PRESETS: dict[str, dict[str, Any]] = {
+    "precise_lookup": {"top_k": 10, "limit": 10, "popularity_weight": 0.15, "use_segmentation": False, "group_mode": "off", "max_per_group": 2},
+    "concept_explore": {"top_k": 80, "limit": 80, "popularity_weight": 0.15, "use_segmentation": True, "group_mode": "expand", "max_per_group": 2},
+    "subject_describe": {"top_k": 20, "limit": 20, "popularity_weight": 0.15, "use_segmentation": False, "group_mode": "off", "max_per_group": 2},
+    "full_scene": {"top_k": 5, "limit": 80, "popularity_weight": 0.15, "use_segmentation": True, "group_mode": "diverse", "max_per_group": 2},
+}
+
+_CATEGORY_MAP: dict[str, list[str]] = {
+    "all": ["General", "Character", "Copyright", "Artist", "Meta"],
+    "general": ["General"],
+    "character": ["Character"],
+    "copyright": ["Copyright"],
+}
+
+
+async def _correct_tags(tagger: DanbooruTagger, tags: list[str]) -> tuple[list[str], list[str], dict[str, str]]:
+    valid_tags: list[str] = []
+    invalid_tags: list[str] = []
+    for tag in tags:
+        if tag in tagger._name_to_idx:
+            valid_tags.append(tag)
+        else:
+            invalid_tags.append(tag)
+
+    corrections: dict[str, str] = {}
+    for bad_tag in invalid_tags:
+        try:
+            request = SearchRequest(
+                query=bad_tag,
+                top_k=5,
+                limit=5,
+                popularity_weight=0.15,
+                use_segmentation=False,
+                target_layers=['英文'],
+            )
+            response = await tagger.search_async(request)
+            if response.results:
+                corrections[bad_tag] = response.results[0].tag
+        except Exception:
+            pass
+
+    corrected_tags: list[str] = []
+    for tag in tags:
+        if tag in valid_tags:
+            corrected_tags.append(tag)
+        elif tag in corrections:
+            corrected_tags.append(corrections[tag])
+
+    return corrected_tags, invalid_tags, corrections
+
+
+def _with_corrections(results: list[dict[str, Any]], corrections: dict[str, str]) -> dict[str, Any]:
+    if not corrections:
+        return {"results": results}
+    correction_notes = [f"{bad} → {good}" for bad, good in corrections.items()]
+    return {
+        "correction_note": "标签拼写错误，已经纠错: " + ", ".join(correction_notes),
+        "corrections": corrections,
+        "results": results,
+    }
 
 
 # ── FastAPI 子应用（挂载到 NiceGUI 的 /api 路径下）──
@@ -114,12 +163,24 @@ app = FastAPI(
 
 # ── 端点 ──
 
-@app.post("/search", response_model=SearchOut)
-async def search(body: SearchIn) -> SearchOut:
+@app.post("/search")
+async def search(body: SearchIn) -> dict[str, Any]:
     tagger = await DanbooruTagger.get_instance()
 
     # SearchIn → core.models.SearchRequest（两者字段一一对应，直接解包）
-    request = SearchRequest(**body.model_dump())
+    preset = _SEARCH_MODE_PRESETS.get(body.search_mode, _SEARCH_MODE_PRESETS["full_scene"])
+    target_categories = _CATEGORY_MAP.get(body.category, _CATEGORY_MAP["all"])
+    request = SearchRequest(
+        query=body.query,
+        top_k=preset["top_k"],
+        limit=preset["limit"],
+        popularity_weight=preset["popularity_weight"],
+        show_nsfw=body.show_nsfw,
+        use_segmentation=preset["use_segmentation"],
+        target_categories=target_categories,
+        group_mode=preset["group_mode"],
+        max_per_group=preset["max_per_group"],
+    )
 
     # 并发安全的异步 search（信号量串行化 + 线程池执行）
     try:
@@ -132,16 +193,31 @@ async def search(body: SearchIn) -> SearchOut:
     await counter.increment_success()
     await counter.increment_copy()
 
-    return SearchOut(
-        tags_all=response.tags_all,
-        tags_sfw=response.tags_sfw,
-        results=[TagOut(**vars(r)) for r in response.results],
-        keywords=response.keywords,
-    )
+    results: list[dict[str, Any]] = []
+    for result in response.results:
+        if result.nsfw == '1' and not body.show_nsfw:
+            continue
+        item = {
+            "tag": result.tag,
+            "cn_name": result.cn_name,
+        }
+        if body.include_wiki:
+            item["wiki"] = result.wiki
+        results.append(item)
+
+    payload: dict[str, Any] = {
+        "prompt": response.tags_sfw if not body.show_nsfw else response.tags_all,
+        "keywords": response.keywords,
+        "results": results,
+    }
+    han_chars = re.findall(r'[\u4e00-\u9fff]', body.query)
+    if body.query and len(han_chars) / len(body.query) < 0.5:
+        payload["hint"] = "检测到英文查询，该搜索引擎对中文查询优化更好，如果搜索结果不合预期，推荐用中文重试"
+    return payload
 
 
-@app.post("/related", response_model=list[RelatedTagOut])
-async def related(body: RelatedIn) -> list[RelatedTagOut]:
+@app.post("/related")
+async def related(body: RelatedIn) -> dict[str, Any]:
     """
     给定已选标签列表，返回基于共现表的关联推荐。
 
@@ -150,9 +226,15 @@ async def related(body: RelatedIn) -> list[RelatedTagOut]:
     - show_nsfw：是否包含 NSFW 标签，默认 True
     """
     tagger = await DanbooruTagger.get_instance()
+    corrected_tags, invalid_tags, corrections = await _correct_tags(tagger, body.tags)
+    if not corrected_tags:
+        return {
+            "error": "所有传入的标签均不存在于标签表中",
+            "invalid_tags": invalid_tags,
+        }
     results = await tagger.get_related_async(
-        body.tags,
-        set(body.tags),   # exclude 已选标签自身
+        corrected_tags,
+        set(corrected_tags),
         body.limit,
         body.show_nsfw,
     )
@@ -161,24 +243,22 @@ async def related(body: RelatedIn) -> list[RelatedTagOut]:
     await counter.increment_success()
     await counter.increment_copy()
 
-    return [
-        RelatedTagOut(
-            tag=r.tag,
-            cn_name=r.cn_name,
-            category=r.category,
-            nsfw=r.nsfw,
-            cooc_count=r.cooc_count,
-            cooc_score=r.cooc_score,
-            sources=r.sources,
-            post_count=r.post_count,
-            wiki=r.wiki,
-        )
-        for r in results
-    ]
+    output: list[dict[str, Any]] = []
+    for result in results:
+        item = {
+            "tag": result.tag,
+            "cn_name": result.cn_name,
+            "sources": result.sources,
+        }
+        if body.include_wiki:
+            item["wiki"] = result.wiki
+        output.append(item)
+
+    return _with_corrections(output, corrections)
 
 
-@app.post("/artists", response_model=list[ArtistOut])
-async def artists(body: ArtistIn) -> list[ArtistOut]:
+@app.post("/artists")
+async def artists(body: ArtistIn) -> dict[str, Any]:
     """
     给定标签列表，推荐擅长绘制这些标签的画师（基于 NPMI 共现数据）。
 
@@ -187,25 +267,37 @@ async def artists(body: ArtistIn) -> list[ArtistOut]:
     - min_cooc：单个 (tag, artist) 对的最小共现次数，默认 3
     """
     tagger = await DanbooruTagger.get_instance()
+    if not body.tags:
+        return {"error": "tags 列表不能为空"}
+
+    corrected_tags, invalid_tags, corrections = await _correct_tags(tagger, body.tags)
+    if not corrected_tags:
+        return {
+            "error": "所有传入的标签均不存在于标签表中",
+            "invalid_tags": invalid_tags,
+        }
+
     results = await tagger.search_artists_by_tags_async(
-        body.tags, limit=body.limit, min_cooc=body.min_cooc,
+        corrected_tags, limit=body.limit, min_cooc=body.min_cooc,
     )
+    artist_names = [result.artist for result in results]
+    top_tags_map = tagger.get_artist_top_tags(artist_names, show_nsfw=body.show_nsfw)
     # 计数
     await counter.increment()
     await counter.increment_success()
     await counter.increment_copy()
 
-    return [
-        ArtistOut(
-            artist=r.artist,
-            score=round(r.score, 4),
-            cooc_count=r.cooc_count,
-            post_count=r.post_count,
-            sources=r.sources,
-            hit_count=r.hit_count,
-        )
-        for r in results
+    output = [
+        {
+            "artist": result.artist,
+            "cooc_count": result.cooc_count,
+            "post_count": result.post_count,
+            "sources": result.sources,
+            "top_tags": top_tags_map.get(result.artist, []),
+        }
+        for result in results
     ]
+    return _with_corrections(output, corrections)
 
 
 @app.get("/health")

mcp_server.py

@@ -90,18 +90,26 @@ Only supported for general, copyright, and character tag searches; **artists and
     "full_scene"       — **DEFAULT.** Use whenever the user gives a concrete picture description: a specific
                          scene, subject(s), clothing, pose, action, or background — no matter how detailed or how
                          many elements. The user wants ONE coherent prompt for ONE intended image.
-                         (e.g. "一个穿着白色水手服的少女在雨中奔跑", "金发双马尾女孩坐在教室窗边看书，夕阳")
+                         (e.g. "一个穿着白色水手服的少女在雨中奔跑", "金发双马尾女孩坐在教室窗边看书，夕阳",
+                              "芙兰朵露 金发 辫子 发带 连衣裙 围裙 灯笼裤")
     "concept_explore"  — **ONLY for open-ended browsing**, when the user wants to SEE A VARIETY of options for a
                          vague/single concept and pick from them — i.e. "show me what kinds of X exist".
                          Returns up to 80 candidates → high token cost. Do NOT use just because a description has
                          many elements; a detailed scene is still "full_scene".
                          (e.g. "各种各样的汉服", "兔耳朵都有哪些", "赛博朋克服装有什么风格")
-    "subject_describe" — Describe **one** subject to find matching tags (e.g. "EVA中蓝发的驾驶员", "两侧有开口，前方有拉绳的运动短裤")
+    "subject_describe" — **WARNING: Only for describing ONE single visual concept.** Tokenizer is DISABLED in this
+                         mode, so it cannot parse multi-element queries. If the query contains a character name +
+                         attributes (e.g. "芙兰朵露 金发 连衣裙"), multiple clothing items, or any combination of
+                         visual elements, you MUST use "full_scene" instead.
+                         Valid use cases: "EVA中蓝发的驾驶员" (single character concept), "灯笼裤" (single item),
+                         "两侧有开口，前方有拉绳的运动短裤" (single item with details).
     "precise_lookup"   — Precise lookup / spell fix (e.g. "selafuku", "thighhigh")
 - DECISION RULE: Does the user want one specific picture (→ full_scene) or to browse many options for a concept
   (→ concept_explore)? A long, multi-element description still maps to full_scene — element count is NOT the signal,
   exploratory intent is.
-- HINT: In subject_describe mode, the tokenizer is disabled, and you can only describe one thing at a time. To search for multiple things at once, use full_scene (for a specific image) or concept_explore (for browsing).
+- CRITICAL: "subject_describe" is ONLY for queries about a SINGLE visual concept (one item, one attribute, one character
+  type). Any query with a character name + attributes, multiple items, or a scene description MUST use "full_scene".
+  When in doubt, use "full_scene" — it handles all concrete image descriptions correctly.
 - category: Filter to a specific tag category. Default "all".
     "all"       — All (通用 + 版权 + 人物)
     "general"   — Visual attributes, clothing, pose, background, etc.
@@ -471,7 +479,7 @@ Anima 是一个 2B 参数的文生图模型（CircleStone Labs × Comfy Org）
 
 ## 情境因果锁（组装前必做）
 
-组装 prompt 前，先建立情境因果链，再拆解为三层内容：
+组装 prompt 前，先建立情境因果链，再拆解为两层内容：
 
 ```
 发生了什么 → 角色的情感/欲望/冲突 → 具体反应（表情+肢体） → 环境如何参与 → 最抓人眼球的画面瞬间
@@ -493,9 +501,9 @@ Anima 是一个 2B 参数的文生图模型（CircleStone Labs × Comfy Org）
 
 ---
 
-## 三层 Prompt 结构
+## 两层 Prompt 结构
 
-prompt 内部分三层组装，同一语义不跨层重复：
+prompt 内部分两层组装，同一语义不跨层重复：
 
 ### 第一层：硬锚点（Hard Tags）
 
@@ -513,23 +521,9 @@ prompt 内部分三层组装，同一语义不跨层重复：
 **不包含：**
 - 未经确认的模糊描述
 - 完整英文句子
-- 构图、光影、氛围（这些交给下两层）
+- 构图、光影、氛围（这些交给下层）
 
-### 第二层：视觉短语（Soft Phrases）
-
-模型根据情境因果生成的短视觉短语，不走 Danbooru 检索，不作为硬锚点。
-
-**包含：**
-- 动作/情感短语示例：`horsing around, having fun, surprised giggling, grinning broadly`
-- 环境效果短语示例：`strong wind, cherry blossom blizzard, petals filling the air`
-- 画师倾向短语：大构图、柔光、戏剧性背光、清透色彩等可见风格结果
-
-**规则：**
-- soft phrase 必须服务于情境因果链，不能变成 loose list。
-- 不查 Danbooru，不进入 confirmed tags。
-- 与 hard tags 不重复、不矛盾。
-
-### 第三层：空间叙事（NL Tags Block）
+### 第二层：空间叙事（NL Tags Block）
 
 有语法结构的连续描述，负责 hard tags 和 soft phrases 难以精确表达的内容。
 特别提示：画面的逻辑需要由空间叙事描述。例如：如果场景有大风，那么画面各处的风向应当一致。如果场景是室内，那么室内桌椅板凳的布局和位置必须合理。
@@ -562,8 +556,6 @@ prompt 内部分三层组装，同一语义不跨层重复：
 ```
 [硬锚点层：逗号分隔，单行]
 
-[视觉短语层：逗号分隔短语]
-
 [空间叙事层：2 到 3 句英文]
 ```
 
@@ -578,7 +570,7 @@ prompt 内部分三层组装，同一语义不跨层重复：
 
 ## 八维补全检查（输出前必做）
 
-三层组装完成后，自查以下 8 个维度，**至少触发 3 维以上**。缺失的维度用空间叙事层补全，不硬塞更多 Danbooru 标签。
+两层组装完成后，自查以下 8 个维度，**至少触发 3 维以上**。缺失的维度用空间叙事层补全，不硬塞更多 Danbooru 标签。
 
 | 维度 | 检查问题 | 缺失表现 | 补全方向 |
 |------|----------|----------|----------|
@@ -696,7 +688,7 @@ masterpiece, best quality, very aesthetic, score_7, safe,
 
 **取景默认**：若用户未指定，默认近景人物、人物面向观众。若用户有描述则以用户描述为准。
 
-**模式默认**：采用 Hybrid 混合结构（硬锚点 + 视觉短语 + 空间叙事）。仅当用户明确要求纯标签或纯自然语言时才切换。
+**模式默认**：采用 Hybrid 混合结构（硬锚点 + 空间叙事）。仅当用户明确要求纯标签或纯自然语言时才切换。
 
 ---
 

ui_nicegui.py

@@ -108,7 +108,6 @@ _SEARCH_MODE_PRESETS: dict[str, dict] = {
 _SEARCH_MODE_OPTIONS = ['自定义'] + list(_SEARCH_MODE_PRESETS.keys())
 
 
-
 # ── 辅助函数 ───────────────────────────────────────────────────────────────────
 
 def _get_git_commit() -> str:
@@ -154,6 +153,11 @@ def _format_tag_with_weight(tag: str, weight: float, fmt: str = 'sdxl') -> str:
     return f'({tag}:{weight:.1f})'
 
 
+def _format_selected_tag_label(tag: str, cn_name: str = '') -> str:
+    cn_first = (cn_name or '').split(',', 1)[0].strip()
+    return f'{tag} | {cn_first}' if cn_first else tag
+
+
 # ── UI 类 ─────────────────────────────────────────────────────────────────────
 
 class DanbooruSearchUI:
@@ -845,6 +849,7 @@ class DanbooruSearchUI:
                 w = self.tag_weights.get(tag, 1.0)
                 extra_cls = 'boosted' if w > 1.0 else ('reduced' if w < 1.0 else '')
                 w_str = f'{w:.1f}'
+                display_label = _format_selected_tag_label(tag, self._get_cn_name_for_tag(tag))
                 with ui.element('div').classes(f'weight-chip {extra_cls}'):
                     # 删除按钮（×）
                     with ui.element('button').classes('weight-btn').props(f'title="移除 {tag}"').on(
@@ -857,9 +862,9 @@ class DanbooruSearchUI:
                     ):
                         ui.html('&minus;')
                     # 标签名
-                    ui.label(tag).style(
+                    ui.label(display_label).style(
                         'font-family:Consolas,Monaco,monospace;font-size:12px;'
-                        'color:#2c5282;max-width:150px;overflow:hidden;'
+                        'color:#2c5282;max-width:240px;overflow:hidden;'
                         'text-overflow:ellipsis;white-space:nowrap;'
                     )
                     # 权重值（仅非 1.0 时显示）
@@ -894,6 +899,26 @@ class DanbooruSearchUI:
         self._save_staged_tags()
         self._render_selected_chips()
 
+    def _get_cn_name_for_tag(self, tag: str) -> str:
+        """尽量从当前 UI 数据中取标签中文名，用于已选区展示。"""
+        if self.result_table is not None:
+            for row in self.result_table.rows:
+                if row.get('tag') == tag:
+                    return str(row.get('cn_name') or '')
+
+        for item in self.current_related:
+            if getattr(item, 'tag', None) == tag:
+                return str(getattr(item, 'cn_name', '') or '')
+
+        try:
+            tagger = DanbooruTagger._instance
+            if tagger and tagger.df is not None and tag in tagger._name_to_idx:
+                idx = tagger._name_to_idx[tag]
+                return str(tagger.df.iloc[idx].get('cn_name', '') or '')
+        except Exception:
+            pass
+        return ''
+
     def _remove_selected_tag(self, tag: str):
         """从已选中移除标签（同步表格选中状态）。"""
         self._mark_interaction()