@yuhan1124/draw-prompt 0.4.7 → 0.4.9

package/README.md

@@ -69,7 +69,9 @@ npx --yes --registry=https://registry.npmjs.org/ @yuhan1124/draw-prompt@latest i
 
 `install-skill` 默认复制 npm 包内的运行文件，避免软链到 npx 缓存导致后续路径失效。它只复制
 `SKILL.md`、CLI、references 和必要元数据；开发仓库里的 `tests/`、`tmp/`、`golden-cases.jsonl`、
-`visual-cases.jsonl` 不会进入 npm 包或安装目录。
+`visual-cases.jsonl` 不会进入 npm 包或安装目录。安装后可直接跑 `doctor`，它会检查
+包文件、版本一致性、核心单图转化、真实长输入 `compose` 链路，以及
+`variants` / `series` / `adapt` 等主工作流 smoke。
 
 开发者本地调试也可以软链 repo：
 

package/SKILL.md

@@ -8,7 +8,7 @@ description: >-
   画图的指令"、"优化我的出图 prompt"、"按我的风格生成 prompt"，或在用 GPT Image 2 /
   gpt-image-2 出图前需要一段精准提示词时，使用本 skill。
 metadata:
-  version: 0.4.7
+  version: 0.4.9
   openclaw:
     anyBins: ["uv", "python3"]
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yuhan1124/draw-prompt",
-  "version": "0.4.7",
+  "version": "0.4.9",
   "description": "Convert natural-language image requests into high-quality gpt-image-2 prompts and Codex handoff blocks.",
   "type": "commonjs",
   "bin": {

package/scripts/prompt_cli.py

@@ -136,7 +136,7 @@ def ensure_home() -> None:
 
 
 SCHEMA_VERSION = 1
-COMPILER_VERSION = "0.4.7"
+COMPILER_VERSION = "0.4.9"
 
 
 PACKAGED_SKILL_FILES = [
@@ -211,6 +211,57 @@ DOCTOR_CASES = [
     },
 ]
 
+DOCTOR_COMPOSE_CASES = [
+    {
+        "id": "long-input-product-plan",
+        "request": (
+            "请把下面这段产品方案整理成 4 张图用于路演：我们要做一个 AI 生图 Prompt 转化 skill。"
+            "目标用户是经常把长文档、产品需求、运营数据、架构说明变成图片的研发和运营同学。"
+            "当前痛点是直接把长输入丢给模型容易跑偏，常见问题包括风格不稳定、中文标签遗漏、架构图被画成 UI、产品图漏卖点、活动战报颜色跑偏。"
+            "方案包括：场景识别、风格预设、意图保持检查、质量门、真实 Image 2 验证、样本反馈学习。"
+            "上线标准是安装后 doctor 通过、常见场景开箱高质量、NPM 公网安装可用。"
+        ),
+        "max_images": 4,
+        "style_preset": "corporate",
+        "expect_count": 4,
+        "expect_no_asset_type": "illustration",
+        "expect_required_text_by_index": {
+            0: ["目标用户"],
+            1: ["当前痛点"],
+            2: ["方案", "场景识别", "风格预设", "质量门"],
+            3: ["上线标准", "NPM 公网安装可用"],
+        },
+    }
+]
+
+DOCTOR_WORKFLOW_CASES = [
+    {
+        "id": "variants-style-envelope",
+        "kind": "variants",
+        "request": "小红书方图，主题 AI 生图 Prompt 三步法，标题 生图 Prompt 三步法",
+        "style_presets": ["premium", "flat-vector"],
+        "expect_count": 2,
+        "expect_required_text": ["AI 生图 Prompt 三步法", "生图 Prompt 三步法"],
+        "forbid_palette": ["小红书方图"],
+    },
+    {
+        "id": "series-consistent-posters",
+        "kind": "series",
+        "briefs": ["茶饮品牌春季主视觉，突出冷泡茶瓶", "同一品牌社媒方图，展示三种口味"],
+        "shared_style": "single coherent series style, same camera language, same palette discipline, same visual density",
+        "style_preset": "premium",
+        "expect_count": 2,
+    },
+    {
+        "id": "adapt-product-brand-and-selling-points",
+        "kind": "adapt",
+        "request": "电商产品详情首屏，品牌 ThermoFlow，展示实时测温、24小时保温、316不锈钢、Type-C 充电",
+        "style_preset": "premium-packshot",
+        "aspects": ["1:1", "3:4", "16:9"],
+        "expect_required_text": ["ThermoFlow", "实时测温", "24小时保温", "316不锈钢", "Type-C 充电"],
+    },
+]
+
 
 def package_root() -> Path:
     return Path(__file__).resolve().parent.parent
@@ -2551,6 +2602,7 @@ def extract_required_texts(request: str, explicit_texts: list[str]) -> list[str]
         r"(?:时间|地点)\s+([^，,、。；;\n]{2,40})",
         r"(?:核心卡片|主要按钮|主按钮|按钮)\s*(?:写上|写|显示|为|是|叫|[:：])\s*([^，,。；;\n]{2,30})",
         r"(?:需要)?包含\s*([A-Za-z][A-Za-z0-9_-]{2,30})\s*字样",
+        r"(?:品牌名|品牌|brand)\s*(?:写上|写|显示|为|是|叫|[:：])?\s*([A-Za-z][A-Za-z0-9_-]{2,30})\b",
         r"(?:名为|叫做|名称是|名字叫)\s*([A-Za-z][A-Za-z0-9_-]{2,30})\b",
     ]
     for pat in labeled_single_patterns:
@@ -2698,8 +2750,9 @@ def infer_style_anchors(request: str, override: str | None, profile: dict, prese
 
 
 def infer_palette_constraints(request: str) -> list[str]:
-    color_terms = [
-        "红", "橙", "黄", "绿", "青", "蓝", "紫", "粉", "黑", "白", "灰", "金", "银", "棕",
+    cjk_colors = "红橙黄绿青蓝紫粉黑白灰金银棕"
+    false_color_tokens = ["小红书", "红书", "白皮书"]
+    direct_color_terms = [
         "深色", "浅色", "渐变", "配色", "主色", "点缀", "背景",
         "red", "orange", "yellow", "green", "cyan", "blue", "purple", "pink", "black", "white",
         "gray", "grey", "gold", "silver", "brown", "gradient", "palette", "color", "colour",
@@ -2712,7 +2765,11 @@ def infer_palette_constraints(request: str) -> list[str]:
             if not fragment:
                 continue
             lower = fragment.lower()
-            if not any(term in lower for term in color_terms):
+            if any(token in fragment for token in false_color_tokens):
+                continue
+            has_direct_color = any(term in lower for term in direct_color_terms)
+            has_cjk_color = re.search(rf"(?:[{cjk_colors}](?:色|系|调|主色|点缀|背景|渐变|不要太俗|高级)|(?:深|浅|亮|暗|磨砂|纯|主|背景|点缀|配色)[^，,。；;\n]{{0,12}}[{cjk_colors}]|黑白)", fragment)
+            if not (has_direct_color or has_cjk_color):
                 continue
             if len(fragment) > 72:
                 fragment = fragment[:72].rstrip()
@@ -4887,6 +4944,30 @@ def split_document_sections(text: str, max_images: int) -> list[str]:
     if buf:
         chunks.append(" ".join(buf).strip())
 
+    if len(chunks) <= 1:
+        semantic_patterns = [
+            r"(目标用户(?:是|：|:)[^。；;\n]+)",
+            r"(用户场景(?:是|：|:)[^。；;\n]+)",
+            r"(当前痛点(?:是|：|:)[^。；;\n]+)",
+            r"(主要问题(?:是|：|:)[^。；;\n]+)",
+            r"(方案(?:包括|是|：|:)[^。；;\n]+)",
+            r"(核心能力(?:包括|是|：|:)[^。；;\n]+)",
+            r"(上线标准(?:是|：|:)[^。；;\n]+)",
+            r"(验收标准(?:是|：|:)[^。；;\n]+)",
+        ]
+        semantic_matches: list[tuple[int, str]] = []
+        seen_spans: set[tuple[int, int]] = set()
+        for pattern in semantic_patterns:
+            for match in re.finditer(pattern, text):
+                span = match.span(1)
+                if span in seen_spans:
+                    continue
+                seen_spans.add(span)
+                semantic_matches.append((span[0], match.group(1).strip()))
+        semantic_chunks = [chunk for _, chunk in sorted(semantic_matches, key=lambda item: item[0])]
+        if len(semantic_chunks) >= 2:
+            chunks = semantic_chunks
+
     if len(chunks) <= 1:
         sentences = [s.strip() for s in re.split(r"(?<=[。！？!?；;])\s*", text) if s.strip()]
         chunks = []
@@ -4908,6 +4989,8 @@ def split_document_sections(text: str, max_images: int) -> list[str]:
 
 def choose_compose_asset(chunk: str, index: int) -> str:
     lower = chunk.lower()
+    if re.search(r"^(?:目标用户|用户场景|当前痛点|主要问题|上线标准|验收标准)", chunk):
+        return "infographic"
     if any(k in lower for k in ["架构", "系统", "模块", "链路", "rag", "llm", "retriever", "pipeline"]):
         return "diagram"
     if any(k in lower for k in ["数据", "指标", "报表", "趋势", "占比", "转化率", "漏斗", "图表"]):
@@ -4922,7 +5005,9 @@ def choose_compose_asset(chunk: str, index: int) -> str:
         return "character"
     if index == 0 and any(k in lower for k in ["标题", "主题", "发布", "活动", "封面", "总结"]):
         return "poster"
-    return "illustration"
+    if any(k in lower for k in ["插画", "场景插图", "故事", "氛围图", "场景图", "scene illustration"]):
+        return "illustration"
+    return "infographic"
 
 
 def infer_compose_style(text: str) -> str:
@@ -4946,6 +5031,13 @@ def extract_visual_labels(chunk: str, asset_type: str, limit: int = 5) -> list[s
 
     for match in re.findall(r'"([^"\n]{1,28})"|“([^”\n]{1,28})”|「([^」\n]{1,28})」', chunk):
         add(next((m for m in match if m), ""))
+    for match in re.finditer(r"(目标用户|用户场景|当前痛点|主要问题|方案|核心能力|上线标准|验收标准)\s*(?:是|包括|包含|：|:)\s*([^。；;\n]{2,140})", chunk):
+        add(match.group(1))
+        value = match.group(2)
+        for part in re.split(r"[、,，/|]", value):
+            part = re.sub(r"^(?:和|与|及|以及|and)\s*", "", part.strip(), flags=re.IGNORECASE)
+            if 1 < len(part) <= 18:
+                add(part)
     for match in re.findall(r"\b[A-Z][A-Za-z0-9_-]{1,20}\b", chunk):
         add(match)
     for match in re.findall(r"(?:标题|主题|模块|步骤|节点|页面)[：:\s]*([^，。；;\n]{2,24})", chunk):
@@ -4964,7 +5056,7 @@ def compose_purpose(asset_type: str, index: int) -> str:
         "ui": "界面概念图",
         "product": "产品视觉图",
         "character": "角色设定图",
-        "illustration": "场景说明图",
+        "illustration": "场景插画",
     }
     return f"{index}. {purpose_map.get(asset_type, '配图')}"
 
@@ -5796,6 +5888,140 @@ def doctor_check_case(case: dict) -> dict:
     }
 
 
+def doctor_check_compose_case(case: dict) -> dict:
+    findings: list[dict] = []
+    text = str(case.get("request") or "")
+    max_images = int(case.get("max_images") or 4)
+    chunks = split_document_sections(text, max_images)
+    shared_style = infer_compose_style(text)
+    visual_plan: list[dict] = []
+    for idx, chunk in enumerate(chunks, start=1):
+        asset_type = choose_compose_asset(chunk, idx - 1)
+        labels = extract_visual_labels(chunk, asset_type)
+        purpose = compose_purpose(asset_type, idx)
+        compiled = compile_visual_case(
+            {
+                "id": f"compose-{idx:02d}",
+                "request": f"{purpose}。根据这段内容生成对应画面：{chunk}",
+                "asset_type": asset_type,
+                "style": shared_style,
+                "style_preset": case.get("style_preset"),
+                "text": labels if asset_type in {"diagram", "infographic", "ui"} else [],
+                "target": "raw",
+                "tags": "compose,long-input",
+            },
+            target="raw",
+            include_handoff=False,
+        )
+        visual_plan.append({"chunk": chunk, "compiled": compiled})
+        for item in compiled["lint"]:
+            findings.append({"severity": item["severity"], "rule": f"compose.{idx}.lint.{item['rule']}", "message": item["message"]})
+        for item in compiled["intent_check"]:
+            findings.append({"severity": item["severity"], "rule": f"compose.{idx}.intent.{item['rule']}", "message": item["message"]})
+
+    if case.get("expect_count") and len(visual_plan) != int(case["expect_count"]):
+        doctor_add(findings, "error", "compose.count", f"期望 {case['expect_count']} 张图，实际 {len(visual_plan)}")
+    forbidden_asset = case.get("expect_no_asset_type")
+    if forbidden_asset:
+        for idx, item in enumerate(visual_plan, start=1):
+            asset_type = item["compiled"]["spec"].get("asset_type")
+            if asset_type == forbidden_asset:
+                doctor_add(findings, "error", "compose.asset_type", f"第 {idx} 张图不应路由为 {forbidden_asset}")
+    for raw_index, expected_texts in (case.get("expect_required_text_by_index") or {}).items():
+        index = int(raw_index)
+        if index >= len(visual_plan):
+            doctor_add(findings, "error", "compose.index_missing", f"缺少第 {index + 1} 张图")
+            continue
+        labels = set(visual_plan[index]["compiled"]["spec"].get("required_text") or [])
+        prompt = visual_plan[index]["compiled"]["prompt"]
+        for text_item in expected_texts:
+            if text_item not in labels:
+                doctor_add(findings, "error", "compose.required_text_missing", f"第 {index + 1} 张图缺少必显文字：{text_item}")
+            elif f'"{text_item}"' not in prompt:
+                doctor_add(findings, "error", "compose.required_text_not_quoted", f"第 {index + 1} 张图 Prompt 未逐字引用：{text_item}")
+    return {
+        "name": f"compose-{case['id']}",
+        "pass": not has_lint_error(findings),
+        "count": len(visual_plan),
+        "asset_types": [item["compiled"]["spec"].get("asset_type") for item in visual_plan],
+        "prompt_digests": [item["compiled"]["prompt_digest"] for item in visual_plan],
+        "required_text": [item["compiled"]["spec"].get("required_text") or [] for item in visual_plan],
+        "findings": findings,
+    }
+
+
+def doctor_check_workflow_case(case: dict) -> dict:
+    findings: list[dict] = []
+    kind = case.get("kind")
+    compiled_items: list[dict] = []
+    if kind == "variants":
+        request = str(case.get("request") or "")
+        for preset in case.get("style_presets") or []:
+            compiled_items.append(
+                compile_visual_case(
+                    {"request": request, "style_preset": preset, "target": "raw", "tags": "doctor,variants"},
+                    target="raw",
+                    include_handoff=False,
+                )
+            )
+    elif kind == "series":
+        shared_style = str(case.get("shared_style") or "")
+        for brief in case.get("briefs") or []:
+            compiled_items.append(
+                compile_visual_case(
+                    {"request": str(brief), "style": shared_style, "style_preset": case.get("style_preset"), "target": "raw", "tags": "doctor,series"},
+                    target="raw",
+                    include_handoff=False,
+                )
+            )
+    elif kind == "adapt":
+        request = str(case.get("request") or "")
+        for aspect in case.get("aspects") or []:
+            compiled_items.append(
+                compile_visual_case(
+                    {"request": request, "aspect": aspect, "style_preset": case.get("style_preset"), "target": "raw", "tags": "doctor,adapt"},
+                    target="raw",
+                    include_handoff=False,
+                )
+            )
+    else:
+        doctor_add(findings, "error", "workflow.kind", f"未知工作流类型：{kind}")
+
+    for idx, item in enumerate(compiled_items, start=1):
+        for lint in item["lint"]:
+            findings.append({"severity": lint["severity"], "rule": f"workflow.{idx}.lint.{lint['rule']}", "message": lint["message"]})
+        for intent in item["intent_check"]:
+            findings.append({"severity": intent["severity"], "rule": f"workflow.{idx}.intent.{intent['rule']}", "message": intent["message"]})
+
+    if case.get("expect_count") and len(compiled_items) != int(case["expect_count"]):
+        doctor_add(findings, "error", "workflow.count", f"期望 {case['expect_count']} 个输出，实际 {len(compiled_items)}")
+    expected_texts = case.get("expect_required_text") or []
+    for idx, item in enumerate(compiled_items, start=1):
+        labels = set(item["spec"].get("required_text") or [])
+        prompt = item["prompt"]
+        for text_item in expected_texts:
+            if text_item not in labels:
+                doctor_add(findings, "error", "workflow.required_text_missing", f"第 {idx} 个输出缺少必显文字：{text_item}")
+            elif f'"{text_item}"' not in prompt:
+                doctor_add(findings, "error", "workflow.required_text_not_quoted", f"第 {idx} 个输出 Prompt 未逐字引用：{text_item}")
+    forbidden_palette = case.get("forbid_palette") or []
+    for idx, item in enumerate(compiled_items, start=1):
+        palette = " ".join(str(part) for part in item["spec"].get("palette") or [])
+        for forbidden in forbidden_palette:
+            if forbidden in palette:
+                doctor_add(findings, "error", "workflow.forbidden_palette", f"第 {idx} 个输出把非颜色词当成配色约束：{forbidden}")
+    return {
+        "name": f"workflow-{case['id']}",
+        "pass": not has_lint_error(findings),
+        "kind": kind,
+        "count": len(compiled_items),
+        "asset_types": [item["spec"].get("asset_type") for item in compiled_items],
+        "prompt_digests": [item["prompt_digest"] for item in compiled_items],
+        "required_text": [item["spec"].get("required_text") or [] for item in compiled_items],
+        "findings": findings,
+    }
+
+
 def cmd_doctor(args: argparse.Namespace) -> int:
     root = package_root()
     checks = [doctor_check_package(root)]
@@ -5804,6 +6030,16 @@ def cmd_doctor(args: argparse.Namespace) -> int:
             checks.append(doctor_check_case(case))
         except Exception as exc:
             checks.append({"name": case.get("id", "case"), "pass": False, "findings": [{"severity": "error", "rule": "case.exception", "message": str(exc)}]})
+    for case in DOCTOR_COMPOSE_CASES:
+        try:
+            checks.append(doctor_check_compose_case(case))
+        except Exception as exc:
+            checks.append({"name": f"compose-{case.get('id', 'case')}", "pass": False, "findings": [{"severity": "error", "rule": "compose.exception", "message": str(exc)}]})
+    for case in DOCTOR_WORKFLOW_CASES:
+        try:
+            checks.append(doctor_check_workflow_case(case))
+        except Exception as exc:
+            checks.append({"name": f"workflow-{case.get('id', 'case')}", "pass": False, "findings": [{"severity": "error", "rule": "workflow.exception", "message": str(exc)}]})
     passed = all(item["pass"] for item in checks)
     summary = {"pass": passed, "version": COMPILER_VERSION, "checks": len(checks), "failed": len([item for item in checks if not item["pass"]])}
     if args.json: