--- name: huo15-img-prompt displayName: 火一五文生图提示词 description: 火一五文生图提示词 v3.0 — AI 创作生态中枢，14 件套：基础八件套（enhance_prompt/enhance_video/reverse_prompt/render_prompt/claude_polish/safety_lint/image_review/auto_iterate）+ v2.6 三件套（character 角色卡/mcp_server MCP stdio/web_ui Web UI）+ ⭐v3.0 三大武器（storyboard 剧本→关键帧+转场视频脚本包/brand_kit 品牌套件持久化/style_learn 多参考图自学习 learned preset）+ RECIPES.md 创意四件套整合食谱。适配 Midjourney/SD/SDXL/Flux/DALL-E 3。触发词：文生图、火一五文生图提示词、文生视频、提示词增强、故事板、storyboard、剧本拆分、关键帧、视频脚本包、品牌套件、brand kit、品牌规范、风格学习、style learn、自学习预设、learned preset、参考图学习、Claude Vision、闭环迭代、五维评审、A/B 测试、角色卡、MCP server、Web UI、Obsidian 集成、Replicate、Fal、即梦、可灵、Hailuo、Sora、Claude Code、Cursor。 version: 3.1.0 aliases: - 火一五文生图提示词 - 火一五文生图技能 - 火一五文生视频技能 - 火一五提示词技能 - 火一五提示词全家桶技能 - 火一五AI绘画技能 - 文生图 - 文生视频 - 提示词增强 - 智能润色 - 平台合规润色 - img-prompt --- # 火一五文生图提示词 v3.0 **AI 创作生态中枢。从单帧提示词到完整短片脚本包，从手选预设到自学习风格，从孤岛工具到与 huo15 设计四件套联动。** ## v3.0 = 14 件套 | # | 脚本 | 作用 | 一行 demo | |---|------|------|-----------| | 1 | `enhance_prompt.py` | 文生图核心 | `enhance_prompt.py "持剑女侠" -p 赛博朋克 --variants 4` | | 2 | `enhance_video.py` | 视频提示词 | `enhance_video.py "汉服少女转身回眸" -p 汉服写真 -m Kling` | | 3 | `reverse_prompt.py` | 参考图反解 | `reverse_prompt.py img.png --mj` | | 4 | `render_prompt.py` | 10 后端直出 | `render_prompt.py "原神少女" -p 原神 --backend jimeng` | | 5 | `claude_polish.py` | Claude 润色 + top-3 推荐 | `claude_polish.py "温柔治愈" --suggest` | | 6 | `safety_lint.py` | 平台合规润色 | `safety_lint.py "战士手中的鲜血" --target dalle` | | 7 | `image_review.py` | Claude Vision 五维评审 | `image_review.py img.png -p "原 prompt"` | | 8 | `auto_iterate.py` | 闭环自动迭代 | `auto_iterate.py "持剑女侠" -p 赛博朋克 --backend dalle --target 7.5` | | 9 | `character.py` | 角色卡持久化 | `enhance_prompt.py "新场景" --char 银发机甲少女` | | 10 | `mcp_server.py` | MCP stdio server | `python3 mcp_server.py`（注册到 ~/.claude/mcp.json） | | 11 | `web_ui.py` | 本地 Web UI | `python3 web_ui.py`（http://127.0.0.1:7155） | | 12 | `storyboard.py` ⭐v3.0 | 剧本→关键帧+转场视频脚本包 | `storyboard.py "..." -p 电影感 --scenes 6 --output ./story` | | 13 | `brand_kit.py` ⭐v3.0 | 品牌套件持久化 | `enhance_prompt.py "..." --brand-kit huo15` | | 14 | `style_learn.py` ⭐v3.0 | 多参考图→learned preset | `style_learn.py --name 我的风格 ref*.jpg && enhance_prompt.py "..." -p "@我的风格"` | 📚 配套文档： - [`QUICKSTART.md`](QUICKSTART.md) ⭐v3.1 — 30 秒/5 分钟/30 分钟分级上手 - [`RECIPES.md`](RECIPES.md) — 5 个端到端食谱 - [`examples/`](examples/) ⭐v3.1 — 真实可运行示例（brand_kit / character / learned_preset / 剧本） - [`scripts/doctor.py`](scripts/doctor.py) ⭐v3.1 — 一键健康检查 - [`tests/smoke.py`](tests/smoke.py) ⭐v3.1 — 33 自动回归测试 ## 版本演进 | 维度 | v2.4 | v2.5 | v2.6 | v3.0 | |------|------|------|------|------| | **风格预设** | 88 + 参考图链接 | + 智能 top-3 | 沿用 | + **自学习 learned preset** | | **一致性** | + session 锁 | + A/B 变体 | + 角色卡 | + **品牌套件全局锁** | | **贴近需求** | + prompt 压缩 | + Claude 改 prompt | 沿用 | + **故事板拆 N 关键帧** | | **生态闭环** | + 10 后端直出 | + VLM 五维评审 | + Obsidian 写入 | + **创意四件套整合** | | **AI 联动** | 多轮编辑 | 闭环自动迭代 | + MCP server | + **跨技能联动** | | **输入** | 一句话主体 | 一句话主体 | 一句话主体 | + **剧本/参考图/品牌规范** | | **输出** | 单帧 prompt | 单帧 prompt | 单帧 prompt | + **完整短片脚本包** | ## 使用方式 ### Agent 调用（推荐） ``` 用户: 帮我出一张赛博朋克街头的图 ``` Agent 识别到"赛博朋克"触发词，自动调用： ```bash ~/workspace/projects/openclaw/huo15-skills/huo15-img-prompt/scripts/enhance_prompt.py \ "赛博朋克街头" -p 赛博朋克 -m Midjourney ``` ### 直接调用 ```bash cd ~/workspace/projects/openclaw/huo15-skills/huo15-img-prompt # 基础：指定预设 ./scripts/enhance_prompt.py "一只猫" -p 动漫 -m Midjourney # 自动意图（无需 -p，脚本从关键词推断） ./scripts/enhance_prompt.py "为咖啡品牌设计一个logo" # → 自动选 Logo设计, 1:1 ./scripts/enhance_prompt.py "产品白底图：无线耳机" # → 自动选产品摄影, 1:1 ./scripts/enhance_prompt.py "微距一滴露珠" # → 自动选微距摄影, 1:1 # 系列一致性（4 张共享 seed + camera/lighting/palette 锁） ./scripts/enhance_prompt.py "红发女侠" -p 动漫 -s 4 \ --variations "持剑站立,骑马奔驰,弯弓射箭,与龙对视" \ -m Midjourney # 英文别名 + 多模型输出 ./scripts/enhance_prompt.py "spaceship in nebula" -p scifi -m Flux -a 21:9 ./scripts/enhance_prompt.py "minimalist camellia logo" -p logo -m SDXL # JSON 输出（便于集成） ./scripts/enhance_prompt.py "森林少女" -p ghibli -j ``` ## 88 款风格预设 ### 【摄影 · 13】写实摄影 / 胶片摄影 / 黑白摄影 / 人像摄影 / 时尚大片 / 美食摄影 / 产品摄影 / 微距摄影 / 航拍摄影 / 街拍纪实 / **暗黑美食 · 日杂 · 街头潮流** ⭐v2.1 ### 【动漫 · 10】动漫 / 新海诚 / 宫崎骏 / 美漫 / Q版 / 童话绘本 / **萌系 · 厚涂 · 轻小说封面 · 赛璐璐** ⭐v2.1 ### 【插画 · 7】水彩 / 油画 / 水墨 / 工笔国画 / 浮世绘 / 线稿 / 像素艺术 ### 【3D · 7】 3DC4D / 盲盒手办 / 低多边形 / 等距视图 / 粘土 / 毛毡手工 / 纸艺 ### 【设计 · 15】极简主义 / 平面设计 / Logo设计 / 图标设计 / 信息图 / 品牌KV / 专辑封面 / 复古海报 / 电影海报 / 表情包 / **玻璃拟态 · 新拟态 · 孟菲斯 · 杂志编排 · 包豪斯 · 奶油风** ⭐v2.1 ### 【艺术史 · 4】印象派 / 后印象派 / 新艺术 / 装饰艺术 ### 【场景氛围 · 17】赛博朋克 / 蒸汽朋克 / 科幻 / 奇幻 / 黑暗奇幻 / 国潮 / Y2K / Vaporwave / 霓虹灯牌 / 建筑可视化 / 电影感 / 概念艺术 / **粗野主义 · 北欧极简 · 侘寂 · 疗愈治愈 · 美式复古** ⭐v2.1 ### 【游戏艺术 · 7】⭐ v2.1 新类原神 / 崩铁星穹 / 英雄联盟 / 暗黑4 / Valorant / Pokemon / 暴雪风 ### 【东方传统 · 7】⭐ v2.1 新类敦煌壁画 / 青花瓷 / 民国月份牌 / 年画 / 剪纸 / 和风 / 汉服写真 > 英文别名支持：`anime`、`ghibli`、`shinkai`、`cyberpunk`、`steampunk`、`scifi`、`minimal`、`logo`、`icon`、`3d`、`c4d`、`octane`、`isometric`、`vangogh`、`artdeco`、`neon`、`vapor`、`y2k`、`genshin`、`lol`、`diablo`、`valorant`、`pokemon`、`dunhuang`、`hanfu`、`wafu`、`glassmorphism`、`neumorphism`、`memphis`、`bauhaus`、`brutalism`、`nordic`、`wabisabi`、`healing`、`cozy`、`americana`、`darkfood`、`muji`、`streetwear`… 运行 `./scripts/enhance_prompt.py -l` 查看完整列表。 ## 参数说明 | 参数 | 作用 | 示例 | |------|------|------| | `subject` | 主体描述（必填） | `"一只猫"` | | `-p, --preset` | 风格预设（中文 / 英文别名） | `-p 赛博朋克` / `-p cyberpunk` | | `-m, --model` | 目标模型 | `Midjourney` / `SD` / `SDXL` / `Flux` / `DALL-E` / `通用` | | `-a, --aspect` | 画幅 | `1:1` / `3:4` / `16:9` / `21:9` / `9:16` | | `-t, --tier` ⭐v2.1 | 质量档位 | `basic` / `pro`(默认) / `master` | | `-cs, --character-sheet` ⭐v2.1 | 角色设定图 T-pose 多视图 | - | | `--avoid` ⭐v2.1 | 额外负面词，逗号分隔 | `--avoid "cluttered, people"` | | `--mood` | 情绪覆盖（不给则从主体自动抽） | `--mood 神秘` | | `--composition` | 构图覆盖 | `--composition 俯拍` | | `--seed` | 种子（不给则按 subject+preset 哈希生成稳定 seed） | `--seed 42` | | `-s, --series` | 系列张数 | `-s 4` | | `--variations` | 系列变体，逗号分隔 | `--variations "A,B,C,D"` | | `-l, --list` | 列出所有预设 | - | | `-j, --json` | JSON 输出 | - | ## 自动抽词（v2.1 扩展）脚本会从主体描述中自动识别以下字段，无需显式参数： | 维度 | 关键词示例 | |------|-----------| | **意图** | logo / 产品 / 海报 / 头像 / 美食 / 汉服 / 敦煌 / 原神 / 玻璃拟态 ... | | **构图** | 特写 / 近景 / 中景 / 全身 / 俯拍 / 仰拍 / 鸟瞰 / 航拍 / 侧面 / 背面 | | **情绪** | 温暖 / 冷峻 / 神秘 / 梦幻 / 欢快 / 忧郁 / 史诗 / 高级 / 治愈 / 浪漫 ⭐v2.1：紧张 | | **时间** ⭐v2.1 | 清晨 / 早晨 / 正午 / 下午 / 黄昏 / 日落 / 夜晚 / 深夜 / 黎明 / 蓝调时刻 | | **天气** ⭐v2.1 | 晴天 / 多云 / 阴天 / 下雨 / 雨天 / 大雨 / 下雪 / 雪天 / 雾天 / 风暴 / 雷雨 | | **季节** ⭐v2.1 | 春/夏/秋/冬 / 樱花季 / 枫叶季 | | **负向需求** ⭐v2.1 | 不要X / 没有X / 避免X / no X / avoid X / without X → 自动入负面 | ## 一致性四锁（核心机制）每个预设内置以下锁项，所有系列张图共享 ⇒ 风格漂移大幅下降： | 锁项 | 作用 | 示例（赛博朋克） | |------|------|----------------| | `camera` | 镜头焦段 / 视角 | `low angle wide, 24mm anamorphic` | | `lighting` | 光源 / 光质 | `neon magenta and cyan rim, wet reflective streets` | | `palette` | 色板 | `magenta cyan black, neon highlights` | | `aspect` | 画幅 | `21:9` | 系列模式 (`-s N --variations ...`) 额外锁定 **seed**，变换仅发生在主体描述，框架完全不变。 ## 模型适配细节 | 模型 | 输出格式 | 特有提示 | |------|---------|---------| | **Midjourney** | `主体, 风格, 光影, 色板, 画质 --ar X:Y --stylize 250` | `--cref ` 锁角色、`--sref ` 锁风格图 | | **Stable Diffusion** | `(subject:1.2), 风格, ..., 质量` + 负面 | 权重语法 `(word:1.3)`、减弱 `[word]`、DPM++ 2M Karras | | **SDXL** | 同 SD，尺寸建议 `1024x1024 / 1216x832 / 1536x640 ...` | Refiner 0.2-0.3 | | **DALL-E 3** | 自然语言段落（已内化负面） | 连续对话中用 "same character / same scene" | | **Flux** | 长句描述 | guidance 3.5（Dev） / 0（Schnell） | | **通用** | 逗号分隔 tags | 三大模型通用骨架 | ## 完整示例 ```bash ./scripts/enhance_prompt.py "一只戴墨镜的猫在霓虹街头" -p 赛博朋克 -m Midjourney ``` 输出： ``` 📌 原始描述 : 一只戴墨镜的猫在霓虹街头 🎨 风格预设 : 赛博朋克 🤖 目标模型 : Midjourney 📐 画幅 : 21:9 🎲 种子建议 : 1873940236 ✅ 正向提示词：一只戴墨镜的猫在霓虹街头, cyberpunk, neon-soaked, blade runner aesthetic, megacity dystopia, holographic ads, low angle wide, 24mm anamorphic, neon magenta and cyan rim, wet reflective streets, magenta cyan black, neon highlights, detailed cyberpunk cityscape, rainy night ambiance, masterpiece, best quality, ultra detailed, 8k --ar 21:9 --stylize 250 ❌ 负向提示词： --no rustic, medieval, natural countryside, low quality, worst quality, ... 🔒 一致性锁： camera : low angle wide, 24mm anamorphic lighting: neon magenta and cyan rim, wet reflective streets palette : magenta cyan black, neon highlights aspect : 21:9 💡 Midjourney tips： • 角色/产品系列一致：加 --cref 或 --sref • 想要更风格化加 --stylize 500~750；更写实降到 --stylize 50 • 建议 seed 锁定：--seed 1873940236 ``` ## v3.0 新功能 ⭐⭐⭐⭐（定位升级：从工具到生态中枢） ### 1. 故事板模式 `storyboard.py` ⭐ 杀手级 feature ```bash storyboard.py "一只猫从城市走进雨夜" -p 电影感 --scenes 4 \ -m Midjourney --video-model Sora --output ./my_story ``` 输入：一段剧本/文案输出（在 `./my_story/`）： - `storyboard.json` 完整 scene + transition 数据 - `scene-{01-N}-t2i.txt` × N 个关键帧 T2I 提示词 - `transition-{xx-to-yy}-t2v.txt` × N-1 个转场 T2V 提示词 - `README.md` 可读总览 + 生产管线说明亮点： - Claude 自动拆叙事弧（开场→起→承→转→合） - 整段共享 base_seed，角色不漂移 - 复用 88 预设/混合/五锁机制 - 视频模型 9 选 1：Sora/Kling/Runway/Pika/Luma/Hailuo/即梦/Wan/通用 - **国内目前没人做到"剧本 → 完整 T2I+T2V 脚本包"** ### 2. 品牌套件持久化 `brand_kit.py` ```bash # 创建品牌套件 brand_kit.py --create song_tea \ --colors "#2C5F2D, #97BC62, #F7F4EA" \ --fonts "Songti SC, Source Han Serif" \ --keywords "宋韵, 极简, 留白, 文人画" \ --forbidden "modern digital, neon, cyberpunk" \ --logo "minimal flame mark in green" # 出图时自动注入 enhance_prompt.py "茶饮品牌主视觉" -p 汉服写真 --brand-kit song_tea ``` 注入位置： - `colors` → 写入 prompt 作为 brand color palette - `keywords` → 追加到主体描述 - `forbidden` → 合并到 negative prompt - `logo_description` → 加入 brand identity 信号完美对接 `huo15-openclaw-brand-protocol` 的输出（其 JSON 可直接 `--import`）。 ### 3. 风格学习引擎 `style_learn.py` ```bash # 给 N 张参考图，Claude Vision 提取共性 → 生成新预设 style_learn.py --name 我的小清新 \ refs/morning_cafe.jpg refs/film_kodak.jpg refs/window_light.jpg # 后续用 @ 前缀调用 enhance_prompt.py "猫咪坐在窗台" -p "@我的小清新" ``` 工作流： 1. 每张图调一次 Claude Vision 提取 tags/camera/lighting/palette 2. 综合阶段让 Claude 归纳共性，输出和 STYLE_PRESETS 兼容的 spec 3. 自带 `confidence` 字段（< 0.5 警告参考图风格太散） 4. 存到 `~/.huo15/learned_presets/.json`，运行期注册到 STYLE_PRESETS ### 4. 创意四件套整合食谱 `RECIPES.md` 5 个端到端食谱，演示和其他 huo15-openclaw-* 技能联动： 1. **品牌 KV 全流程**：design-director → brand-protocol → brand_kit → img-prompt → design-critique → frontend-design 2. **自学习风格 + 角色一致性 + 视频短片**：style_learn → character → storyboard 3. **电商商品图全套**：brand_kit + variants + character + obsidian 4. **Claude Code MCP 工作流**：IDE 内自然语言调用 5. **knowledge-base 联动**：资产沉淀到知识库 ### 这一版的定位升级 | | v2.x | v3.0 | |---|------|------| | 输入 | 一句话主体 | 一段剧本 / 多张参考图 / 品牌规范 | | 输出 | 单帧 prompt | **完整短片脚本包 + 学到的新预设 + 品牌一致出图** | | 个性化 | 88 内置预设 | + **用户自学习风格 + 品牌套件** | | 生态位 | 独立工具 | + **创意四件套核心节点**（5 个 huo15 技能联动） | ## v2.6 新功能 ⭐⭐⭐（用户群从 CLI → IDE/GUI/笔记四栖） ### 1. 角色卡持久化 `character.py` ```bash # Turn 1: 创建角色（带 character-sheet 模式） enhance_prompt.py "银发机甲少女 twin tails glowing visor" \ -p 动漫 --character-sheet --save-char 银发机甲少女 # Turn 2 ~ N: 跨调用保持角色一致（自动锁 seed + 注入主体） enhance_prompt.py "在霓虹街头" --char 银发机甲少女 -p 赛博朋克 enhance_prompt.py "在花海中" --char 银发机甲少女 enhance_prompt.py "持剑战斗" --char 银发机甲少女 # 角色卡管理（独立 CLI） character.py --list character.py --show 银发机甲少女 character.py --export 银发机甲少女 > char.json cat char.json | character.py --import ``` 存储：`~/.huo15/characters/.json`，含 use_count + 时间戳 + 五锁。 ### 2. Obsidian 集成 `--obsidian` ```bash # 默认检测 ~/knowledge/huo15 / ~/Documents/Obsidian / ~/Obsidian enhance_prompt.py "敦煌神女" -p 敦煌壁画 --obsidian # 指定 vault OBSIDIAN_VAULT=~/my-vault enhance_prompt.py "..." -p 原神 --obsidian ``` 写入 `/图集/{date}-{subject}-{seed}.md`，含完整 frontmatter（tags/preset/seed/...）+ 正负向提示词 + 一致性锁 + 复现 CLI 命令。跟 huo15 三层记忆生态吻合（L3 共享 KB wiki）。 ### 3. MCP server `mcp_server.py` ⭐ IDE 用户的入口让 **Claude Code / Cursor / Cline / Continue.dev** 直接调用 9 个工具： ```json // ~/.claude/mcp.json { "mcpServers": { "huo15-img-prompt": { "command": "python3", "args": ["~/path/to/huo15-img-prompt/scripts/mcp_server.py"] } } } ``` 暴露的工具： - `enhance_prompt` / `list_presets` / `preset_examples` - `suggest_presets` / `polish_prompt` / `safety_lint` - `review_image` / `list_characters` / `load_character` 实现：手写 JSON-RPC 2.0 over stdio，零第三方依赖。 ### 4. 本地 Web UI `web_ui.py` ⭐ 设计师/PM 用户的入口 ```bash python3 web_ui.py # 默认 http://127.0.0.1:7155 python3 web_ui.py --port 8080 python3 web_ui.py --no-browser ``` 特性： - 单文件 HTML（vanilla JS + Tailwind CDN，零构建） - Python `http.server.ThreadingHTTPServer` 做后端 - 三栏布局：输入 / 88 预设可视化 / 实时输出 - 角色卡下拉选择 + 一键复制 - 自动开浏览器、Ctrl+C 退出 ## v2.5 新功能 ⭐⭐⭐（核心护城河） ### 1. Claude Vision 五维评审 `image_review.py` ```bash # 单图评审 image_review.py img.png --prompt "原始 prompt" # 多图排名（同一组 variants 出图后挑最优） image_review.py renders/*.png --rank ``` 输出： - 五维分数（0-10）：subject_match / composition / lighting / palette / technical - 加权 overall_score + 三档 verdict（PASS/RETRY/REJECT） - **可执行修复**：每条 issue 不写"光线不好"，直接给 `add: golden hour rim light, soft fill from camera left` - 简评模式 `--quick`（只 overall_score，省 token） ### 2. 闭环自动迭代 `auto_iterate.py` ⭐ 杀手级 feature ``` ┌──────────────┐ │ user prompt │ └──────┬───────┘ ↓ ┌─────────────────────┐ │ enhance_prompt │ └─────────┬───────────┘ ↓ ┌─────────────────────┐ │ render (10 后端) │ └─────────┬───────────┘ ↓ ┌─────────────────────┐ │ Claude Vision │ │ 五维评审 │ └─────────┬───────────┘ ↓ 分数 ≥ 阈值? ↙ ↘ Y N (≤ 3 轮) ↓ ↓ 完成 ┌────────────┐ │ Claude 改 │ │ prompt │ └─────┬──────┘ ↑ (回到 enhance) ``` ```bash auto_iterate.py "持剑女侠" -p 赛博朋克 --backend dalle --target 7.5 --max-rounds 3 ``` 每轮锁定 seed，便于对比 prompt 改动到底改善了哪一维。Claude 的修改基于上轮 review 的 actionable_fixes，输出 revised_subject + extra_negatives + extra_mood + rationale。 **这个能力 GPT-4o image / Claude Imagen 内部做不到** — 它们是端到端黑盒，没有 prompt-image 闭环数据。 ### 3. A/B 变体测试 `--variants N` ```bash # 同 subject + 同 seed，仅在 mood/composition 上分化出 4 个变体 enhance_prompt.py "持剑女侠" -p 赛博朋克 --variants 4 -j > variants.json # 出图后挑最优 image_review.py renders/*.png --rank ``` 四个差异轴可选：`mood / composition / lighting / stylize`，`--variant-axes mood,lighting` 自定义。 ### 4. 智能预设推荐 `--suggest` ```bash # 模糊描述也能自动匹配预设 enhance_prompt.py "温柔治愈感的画面" --suggest ``` 输出：top-3 候选预设 + 每个的 score (0-1) + reason + best_subject_example + mix_suggestion（自动判断是否需要混合）。解决"温柔"、"高级"、"梦幻"等抽象描述硬关键词匹配不到的痛点。 ## v2.4 新功能 ⭐ ### 1. render_prompt.py 扩到 10 后端 ```bash # 国际开源 render_prompt.py "侠客" -p 水墨 --backend replicate --remote-model black-forest-labs/flux-schnell render_prompt.py "猫" -p 动漫 --backend fal --remote-model fal-ai/flux/dev # 国产模型（中文场景效果好） render_prompt.py "敦煌神女" -p 敦煌壁画 --backend jimeng # 字节即梦 / Seedream 3.0 render_prompt.py "汉服少女" -p 汉服写真 --backend kling # 快手可灵 v1 render_prompt.py "原神少女" -p 原神 --backend hailuo # 海螺 MiniMax image-01 ``` 环境变量：`REPLICATE_API_TOKEN` / `FAL_KEY` / `ARK_API_KEY`（火山方舟）/ `KLING_API_KEY` / `MINIMAX_API_KEY`。 ### 2. prompt 压缩 `--compact` ```bash enhance_prompt.py "持剑女侠" -p "赛博朋克+水墨" -m SD --compact # 🗜 prompt 已压缩: 124→73 tokens (砍 12 段) ``` 策略：去重 → 同义合并 → 保头 6 段（主体+camera）→ 按预算砍尾。专治 SDXL CLIP 77 token 截断。 ### 3. 88 预设参考图链接 `--examples` ```bash # 看单个预设的参考图（5 平台搜索 URL） enhance_prompt.py --examples 敦煌壁画 # 列表模式带链接 enhance_prompt.py -l --with-examples ``` 输出 5 平台搜索 URL：Lexica / Civitai / Pinterest / Google Images / Unsplash。零维护，靠搜索 query 永远有效。 ### 4. 多轮编辑 `--session` / `--continue` ```bash # Turn 1: 出图 enhance_prompt.py "猫坐在窗台" -p 写实摄影 --session catwindow # Turn 2: 改画幅 + 加情绪，seed 自动锁定保证主体一致 enhance_prompt.py --continue catwindow --aspect 16:9 --mood 治愈 # Turn 3: 完全换主体描述但保 seed 测一致性 enhance_prompt.py "猫站起来伸懒腰" --continue catwindow # 列出所有 session enhance_prompt.py --list-sessions ``` 持久化目录：`~/.huo15/sessions/.json`。CLI 参数 > session 默认值 > 系统默认。 ## v2.3 新功能 ⭐ ### 5. Claude API 智能润色 `--polish` ```bash # 直接润色（独立调用） export ANTHROPIC_API_KEY=sk-ant-xxx ./scripts/claude_polish.py "一个温柔的女孩在花丛中" ./scripts/claude_polish.py "敦煌神女" --pipe # 输出可直接喂给 enhance_prompt.py 的命令 # 在 enhance_prompt.py 里串联使用（润色 → 88 预设 → 输出） ./scripts/enhance_prompt.py "一个温柔的女孩在花丛中" --polish ./scripts/enhance_prompt.py "雪山下的小屋" --polish --safety MJ -m Midjourney ``` 利用 Claude prompt engineering 优势： - **Prompt caching**：system prompt 用 ephemeral cache，省 90% input token - **Prefill `{`**：assistant 起手 `{` 强制 JSON 输出，无需 tool use - **XML 思维链**：让 Claude 内部分步骤（refine/style/camera/safety/negatives） - **88 预设嵌入 system**：Claude 从清单里挑，不凭记忆 - **零 SDK 依赖**：纯 urllib，避免企业扫描器拦截 anthropic 包 ### 6. 平台合规润色 `--safety` **只做合法艺术创作的平台误判规避，不做 jailbreak。** ```bash # 独立调用 ./scripts/safety_lint.py "战士手中沾满鲜血的剑" --target dalle ./scripts/safety_lint.py "古典维纳斯雕像 nude figure" --target MJ --apply ./scripts/safety_lint.py "如何制作炸弹" # 命中红线 → exit 2 # 在 enhance_prompt.py 里串联 ./scripts/enhance_prompt.py "古风战场鲜血飞溅" --safety dalle ./scripts/enhance_prompt.py "黑暗骑士斩杀恶魔" --safety MJ -p 黑暗奇幻 ``` **红线（直接拒答）**： - ✗ CSAM（未成年 + 性化任意组合） - ✗ 真人 + 色情/政治污蔑 - ✗ 武器/毒品/爆炸物**制作方法/教程** - ✗ 自残/自杀**方法诱导** **黄区（艺术化重写）**： | 类别 | 例子 | 重写策略 | |------|------|----------| | violence | 血、伤口、kill、weapon | crimson splash / battle-scarred / vanquish / ceremonial blade | | nudity | 裸、naked、sexy | classical figure study / fine art reference / fashion editorial | | horror | horror、gore、demon | gothic atmospheric tension / mythical creature | | death | dead、skeleton、skull | memento mori / classical allegory / vanitas | | real-person | celebrity、明星、politician | fictional character / 80s aesthetic | | brand | marvel、disney、nike | superhero comic style / classic animated | **平台分级**： - DALL-E `max` 严格度 - MJ `high` 中等 - SD/SDXL/Flux `low` 宽松（开源本地） ### 7. Polish + Safety 串联（最强组合） ```bash # Claude 智能润色 → 平台合规重写 → 88 预设增强 ./scripts/enhance_prompt.py "战士在血战之后凝视远方" --polish --safety dalle -j ``` 输出 JSON 包含 `claude_polish` 和 `safety_lint` 两个完整 meta 块，可追溯每一步改写过程。 ## v2.2 新功能详解 ### 1. 混合预设 `-p A+B --mix 0.6` ```bash # 主预设 60% 权重，副预设 40% enhance_prompt.py "持剑女侠" -p "赛博朋克+水墨" --mix 0.6 -m Midjourney enhance_prompt.py "山中神女" -p "原神+敦煌壁画" --mix 0.5 -m SDXL enhance_prompt.py "极简卡片" -p "玻璃拟态+侘寂" --mix 0.7 -m SD ``` 融合策略： - **tags**：主预设标签前置，副预设按权重补充；SD 自动加权重语法 `(tag:1.16)` - **camera**：取主预设（避免镜头语言混乱） - **lighting**：叠加 `主光照, blended with 副光照` - **palette**：拼接两者 - **aspect**：取主预设默认画幅 - **neg**：合并去重 + PRESET_NEG_EXCLUDE 主辅都生效（避免 logo/text/signature 自我否定） - **seed**：mix_label `A+B@0.60` 参与 hash，相同混合每次同 seed ### 2. 视频提示词 `enhance_video.py` ```bash # Sora 8 秒赛博朋克 enhance_video.py "雨夜霓虹街头一只猫漫步" -p 赛博朋克 -m Sora --duration 8 # Kling 慢速跟拍 enhance_video.py "汉服少女转身回眸" -p 汉服写真 -m Kling --motion 慢速跟拍 # 史诗节奏 + 自定义动作 enhance_video.py "宇宙飞船穿越星云" -p scifi -m Runway --pacing 史诗 --action "ship accelerates, lens flare" # 混合风格 + 海螺 MiniMax enhance_video.py "山中神女腾云" -p "原神+敦煌壁画" --mix 0.6 -m Hailuo # 列出所有视频模型规格 enhance_video.py --list-models ``` 支持的视频模型： | 模型 | 上限时长 | 默认画幅 | 提示词风格 | |------|---------|---------|-----------| | Sora | 20s (Sora 2 Pro) | 16:9 | 长自然语言 | | Kling 可灵 | 10s (1080p Pro) | 16:9 | 中文优秀，前置主体 | | Runway Gen-3/4 | 10s | 16:9 | 英文最佳 | | Pika | 10s | 16:9 | 标签式 + `-gs/-motion` | | Luma DreamMachine | 9s | 16:9 | 自然语言 + 关键帧 | | Hailuo MiniMax | 10s | 16:9 | 中英双语 + 参考人物 | | 即梦 Seedance | 12s | 16:9 | 中文多镜头剧情 | | 通义 Wan2.1 | 8s | 16:9 | 阿里开源 14B/1.3B | 输出包含：正向 / 负向（视频专属：flicker、motion blur、identity drift）/ 三段式关键帧 / 一致性六锁（+ motion）。 ### 3. 参考图反解 `reverse_prompt.py` ```bash # 自动识别 A1111/ComfyUI/NovelAI metadata reverse_prompt.py /path/to/image.png # 远程 URL reverse_prompt.py https://example.com/img.png # 直接给 Midjourney 复用 prompt（一行） reverse_prompt.py img.png --mj # 强制 VLM 模板（图无 metadata） reverse_prompt.py img.png --vlm # JSON pipe 给 enhance_prompt.py reverse_prompt.py img.png -j > recipe.json ``` 三层反解： 1. **PNG metadata**：手写 `tEXt`/`iTXt` 解析，零 PIL 依赖 2. **A1111 / ComfyUI / NovelAI 三大格式自动识别** 3. **VLM fallback**：图无 metadata 时输出标准 prompt 给 GPT-4o/Claude/Gemini/Qwen-VL 启发式预设猜测：35+ 关键词映射（cyberpunk → 赛博朋克 / ghibli → 宫崎骏 / dunhuang → 敦煌壁画 ...）。 ### 4. 直出图片 `render_prompt.py` ```bash # Dry-run（只输出 recipe，不出图） render_prompt.py "敦煌神女" -p 敦煌壁画 --backend none -j # AUTOMATIC1111 / Forge SD WebUI render_prompt.py "赛博朋克猫" -p 赛博朋克 --backend sd-webui # ComfyUI（用内置 SDXL workflow） render_prompt.py "原神少女" -p 原神 --backend comfyui # ComfyUI（自定义 workflow） render_prompt.py "原神少女" -p 原神 --backend comfyui --workflow ./workflows/sdxl.json # DALL-E 3 render_prompt.py "极简logo" -p Logo设计 --backend dalle --size 1024x1024 ``` 特点： - **零第三方依赖**：纯 urllib，避免企业扫描器命中 - **环境变量覆盖**：`COMFYUI_URL` / `SDWEBUI_URL` / `OPENAI_API_KEY` - **支持混合预设直出** ## 参考文档 `references/t2i-guide.md` — 提示词要素表 / 88 预设对照 / 模型差异 / 一致性技巧。 ## 版本历史见 `CHANGELOG.md`。 FILE:CHANGELOG.md # Changelog ## v3.1.0 — 2026-04-27 **稳定加固版：质量基础设施 + 上手文档 + 真实示例。不堆功能，先把底子打牢。** 发完 v3.0 大版本（14 件套、1770 行新代码、3 个新外部 API 集成）后，发现： - 14 件套互相依赖，没自动化回归 → 改动风险高 - 新用户拿到不知道从哪开始 - 错误处理散在脚本里不统一 - API key / 服务可达性没统一诊断入口 v3.1 不加 feature，只补这些短板。 ### 新增 1: doctor.py — 健康检查（~250 行） ```bash python3 scripts/doctor.py # 全量 python3 scripts/doctor.py --quick # 跳过网络 python3 scripts/doctor.py --check api # 只查 API keys python3 scripts/doctor.py -j # JSON 输出 ``` 检查项： - 14 个脚本 import + VERSION 一致性 - 7 个 API key（ANTHROPIC 必填，其他按需） - 2 个本地后端（ComfyUI / SD WebUI）可达性 - 4 个候选 Obsidian vault 路径 - 4 个持久化目录盘点（characters / sessions / brand_kits / learned_presets） - Claude API 实测 ping（用 haiku 最便宜模型）输出：彩色 ✓ / ⚠ / ✗ 表格 + 总结统计。 ### 新增 2: tests/smoke.py — 自动回归测试（~250 行）零依赖、纯本地、不调网络。33 个测试覆盖核心 API： - 版本号一致性（15 个脚本） - enhance_prompt 核心：resolve_preset / parse_mix_preset / build_prompt / mix / character_sheet / seed 稳定 - compact_prompt 长短场景 - safety_lint 红线 / 艺术化重写 / 双向 catch - character / brand_kit save-load roundtrip + apply 注入 - variants 共享 seed - reverse_prompt A1111 解析 + 启发式 preset 猜 - MCP server: initialize / tools/list / tools/call dispatch - 88 预设字段完整性 ```bash tests/smoke.py # 全跑 tests/smoke.py --module TestSafetyLint ``` 实测：33 测试 0.089 秒跑完。 ### 新增 3: examples/ 目录 — 5 个真实可运行示例 | 文件 | 用途 | |------|------| | `brand_kit-song_tea.json` | 宋韵东方茶饮品牌套件示例 | | `character-silver_mecha.json` | 银发机甲少女角色卡 | | `learned_preset-fresh_film.json` | 清新胶片风学习预设 | | `storyboard-cat_rainy_night.txt` | 6 帧短片剧本（一只猫的雨夜散步） | | `recipe-1-brand_kv.sh` | RECIPES 食谱 1 的完整 bash 脚本 | | `examples/README.md` | 导入指南 | 直接 `cat examples/xxx.json | scripts/<模块>.py --import` 即用。 ### 新增 4: QUICKSTART.md — 三层级上手文档 - **30 秒**：第一条命令 - **5 分钟**：基础工作流（推荐预设 → 出图 → 保存角色卡 → 看示例图） - **30 分钟**：完整工作流（品牌 KV / 风格学习 / 故事板 / IDE / Web UI / Obsidian） - **6 个 FAQ**：API key 缺失能用哪些功能 / 哪些后端值得配 / prompt 太长怎么办 / 等 ### 兼容性 - 纯加固，零 feature 改动 - doctor.py / tests/smoke.py / examples/ / QUICKSTART.md 全是新增 - 14 个 v3.0 脚本不变，仅 VERSION bump 到 3.1.0 ### 文件改动 | 改动 | 内容 | |------|------| | 新文件 | `doctor.py` / `tests/smoke.py` / `QUICKSTART.md` / `examples/*` (6 文件) | | VERSION bump | 14 个脚本 v3.0.0 → v3.1.0 | | 总新增 | ~900 行（含 5 个示例文件） | ### 这一版的意义 | | v3.0 | v3.1 | |---|------|------| | 代码质量 | 14 件套手动 smoke | + **33 自动回归** | | 上手成本 | RECIPES.md 抽象 | + **30 秒/5 分钟/30 分钟分级** | | 错误诊断 | 各脚本散写 | + **doctor.py 一键体检** | | 示例素材 | 文档里截图 | + **examples/ 真实文件** | --- ## v3.0.0 — 2026-04-27 **v3.0 大版本：从"提示词工具"升级为「AI 创作生态中枢」。** 四件大武器同时上线：故事板模式 / 品牌套件 / 风格学习引擎 / 创意四件套整合 cookbook。 ### E3: storyboard.py — 故事板模式（新文件 ~430 行）⭐ 杀手级 feature 把一段剧本/文案 → Claude 拆 N 关键帧 → 每帧 T2I prompt + 帧间 T2V 衔接 prompt → 完整短片脚本包。 ```bash storyboard.py "一只猫从城市走进雨夜" -p 电影感 --scenes 4 \\ -m Midjourney --video-model Sora --output ./my_story ``` 输出： - `storyboard.json`（完整 scene + transition 数据） - `scene-{01-N}-t2i.txt`（每个关键帧的 T2I 提示词） - `transition-{xx-to-yy}-t2v.txt`（每个转场的 T2V 提示词） - `README.md`（可读总览 + 生产管线）亮点： - 整段共享 base_seed 锁定一致性，主角不漂移 - Claude 自动拆分叙事弧（开场→起→承→转→合） - 复用 enhance_prompt + enhance_video，所有 88 预设/混合/五锁全部生效 - 视频模型 9 选 1：Sora/Kling/Runway/Pika/Luma/Hailuo/即梦/Wan **国内目前没有人做到"剧本 → 完整 T2I+T2V 脚本包"这一点。** ### E4: brand_kit.py — 品牌套件持久化（新文件 ~280 行）品牌 VI 沉淀到 `~/.huo15/brand_kits/.json`，包含 colors / fonts / keywords / forbidden / logo_description。 ```bash brand_kit.py --create song_tea \\ --colors "#2C5F2D, #97BC62, #F7F4EA" \\ --fonts "Songti SC, Source Han Serif" \\ --keywords "宋韵, 极简, 留白, 文人画" \\ --forbidden "modern digital, neon, cyberpunk" # 出图时自动注入 enhance_prompt.py "茶饮品牌主视觉" -p 汉服写真 --brand-kit song_tea ``` 注入逻辑： - `colors` → 写入 prompt 作为 brand color palette 提示 - `keywords` → 追加到主体描述 - `forbidden` → 合并到 negative prompt - `logo_description` → 加入 prompt 作 brand identity 信号完美对接 `huo15-openclaw-brand-protocol` 的输出（其抓品牌规范的 JSON 可直接 `--import`）。 ### C4: style_learn.py — 风格学习引擎（新文件 ~330 行）给 N 张参考图（≥2），Claude Vision 提取每张特征 → 综合共性 → 生成 learned preset。 ```bash style_learn.py --name 我的小清新 ref1.jpg ref2.jpg ref3.jpg # 后续直接用 @ 前缀调用 enhance_prompt.py "猫咪" -p "@我的小清新" ``` 技术细节： - 每张图调一次 Claude Vision 提取 tags/camera/lighting/palette/aspect - 综合阶段让 Claude 统一归纳，输出和 STYLE_PRESETS schema 兼容的 spec - 自带 `confidence` 字段（共性强度 0-1，< 0.5 警告太散） - 存到 `~/.huo15/learned_presets/.json`，运行期注册到 STYLE_PRESETS（不污染源文件） - `resolve_preset` 支持 `@` 前缀 ### G2: RECIPES.md — 创意四件套整合食谱新文档：5 个端到端食谱，演示 huo15-img-prompt 和其他 huo15-openclaw-* 技能联动： 1. **品牌 KV 全流程**（design-director → brand-protocol → brand_kit → img-prompt → design-critique → frontend-design） 2. **自学习风格 + 角色一致性 + 视频短片**（style_learn → character → storyboard） 3. **电商商品图全套**（brand_kit + variants + character + obsidian） 4. **Claude Code MCP 工作流**（IDE 内自然语言调用） 5. **knowledge-base 联动**（资产沉淀到知识库）设计原则： - 每个技能管自己一段（不重复造轮子） - 数据格式互通（brand_kit / character / learned_preset 都是标准 JSON） - Claude Code + MCP 当协调者 - 闭环优先（v2.5 的 image_review 免费用） ### enhance_prompt.py 集成 - 新增 `--brand-kit ` 加载品牌套件 - `resolve_preset` 支持 `@` 前缀加载 learned preset ### 所有新文件（v3.0 共 ~1800 行） | 文件 | 行数 | 关键能力 | |------|------|---------| | `storyboard.py` | 430 | 剧本 → 视频脚本包 | | `brand_kit.py` | 280 | 品牌套件持久化 | | `style_learn.py` | 330 | 风格学习引擎 | | `RECIPES.md` | 250 | 创意四件套食谱 | | `enhance_prompt.py` | + 50 | brand-kit 注入 + @learned 解析 | ### 兼容性 - 完全向下兼容 v2.6 - 所有新参数有默认值 - learned preset 用 `@` 前缀，不与 88 内置预设冲突 - 新文件不影响老脚本 ### 这一版的定位升级 | | v2.x | v3.0 | |---|------|------| | 输入 | 一句话主体 | 一段剧本 / 多张参考图 / 品牌规范 | | 输出 | 单帧 prompt | **完整短片脚本包** / **学到的新预设** / **品牌一致出图** | | 个性化 | 88 内置预设 | + **用户自学习风格** + **品牌套件** | | 生态位 | 独立工具 | + **创意四件套核心节点**（食谱整合 5 个 huo15 技能） | --- ## v2.6.0 — 2026-04-27 **用户体验大版本：从 CLI 工具变成 GUI/IDE/笔记三栖产品。** ### E1: character.py — 角色卡持久化（新文件 220 行） - 把 `--character-sheet` 模式的输出（subject 描述 + seed + camera/lighting/palette 五锁）存到 `~/.huo15/characters/.json` - 新增两个 enhance_prompt.py 参数： - `--save-char ` 保存当前调用为角色卡 - `--char ` 加载角色卡，自动注入主体 + 锁 seed/preset/aspect - 角色卡含 `use_count` 自增计数 + `created_at` / `updated_at` 时间戳 - 独立 CLI 管理：`character.py --list / --show / --delete / --export / --import` - 用例： ```bash # Turn 1: 创建角色 enhance_prompt.py "银发机甲少女 twin tails glowing visor" -p 动漫 \\ --character-sheet --save-char 银发机甲少女 # Turn 2 ~ N: 复用，多张图角色一致 enhance_prompt.py "在霓虹街头" --char 银发机甲少女 -p 赛博朋克 enhance_prompt.py "在花海中" --char 银发机甲少女 ``` ### D2: Obsidian 集成 — `--obsidian` 写入 vault - 自动检测 vault 路径（环境变量 `OBSIDIAN_VAULT` → `~/knowledge/huo15` → `~/Documents/Obsidian` → `~/Obsidian`） - 写入 `/图集/{date}-{subject}-{seed}.md` - 完整 frontmatter（tags/preset/model/aspect/seed/tier/version/date/mix） - markdown body 包含：原始描述、正负向提示词、一致性锁、元信息、Claude 润色记录、VLM 评审、复现 CLI 命令 - 跟用户记忆里的"L3 共享 KB wiki"层级吻合，完成 huo15 三层记忆生态闭环 ### D3: mcp_server.py — MCP stdio server（新文件 280 行）让 **Claude Code / Cursor / Cline / Continue.dev** 等 MCP IDE 直接调用本技能的 9 个工具： - `enhance_prompt` — 88 预设 + 五锁 - `list_presets` / `preset_examples` — 浏览预设 + 5 平台参考图链接 - `suggest_presets` / `polish_prompt` — Claude 智能推荐 + 润色 - `safety_lint` — 平台合规检查 - `review_image` — Claude Vision 五维评审 - `list_characters` / `load_character` — 角色卡管理实现细节： - **手写 JSON-RPC 2.0 over stdio**，零第三方依赖（不引 mcp SDK） - 完整 MCP 协议：initialize / tools/list / tools/call - 注册到 `~/.claude/mcp.json`： ```json { "mcpServers": { "huo15-img-prompt": { "command": "python3", "args": ["/path/to/scripts/mcp_server.py"] } } } ``` ### D1: web_ui.py — 本地 Web UI（新文件 380 行） ```bash python3 web_ui.py # 默认 http://127.0.0.1:7155 python3 web_ui.py --port 8080 python3 web_ui.py --no-browser ``` - 单文件 HTML（vanilla JS + Tailwind CDN，零构建） - Python `http.server.ThreadingHTTPServer` 当后端，零第三方依赖 - 三栏布局： - 左：主体输入 + 混合预设权重 + 画质 + 模型 + 画幅 + 角色卡选择 - 中：88 预设可视化卡片，按 9 大类分组，搜索过滤 - 右：实时正/负向提示词 + 一致性锁表格 + 元信息 + 一键复制 - 自动开浏览器、Ctrl+C 退出 ### 全部新文件（v2.6 共 ~880 行） | 脚本 | 行数 | 用户群 | |------|------|--------| | `character.py` | 220 行 | CLI + 程序化复用 | | `mcp_server.py` | 280 行 | IDE 用户（Claude Code/Cursor） | | `web_ui.py` | 380 行 | 设计师/产品经理（GUI） | | `enhance_prompt.py` | + 80 行（save-char/char/obsidian + helpers） | — | ### 兼容性 - 完全向下兼容 v2.5 - 新参数有默认值 - 新文件不影响老脚本 ### 用户群拓展 | 之前 | 现在 | |------|------| | 命令行用户 | + IDE 用户（MCP）+ GUI 用户（Web UI）+ Obsidian 用户 | | 单次调用 | + 跨调用一致性（角色卡）+ 三层记忆同步（Obsidian） | --- ## v2.5.0 — 2026-04-27 **核心护城河上线：图生评审 + 闭环自动迭代。GPT-4o image / Claude Imagen 内部都做不到。** ### C1: image_review.py — Claude Vision 五维评审（新文件 320 行） - 调 Claude Sonnet 4.5 Vision 评审一张图 - 五维结构化打分（0-10）：subject_match / composition / lighting / palette / technical - 输出加权 overall_score（subject 0.3 / composition 0.2 / lighting 0.2 / palette 0.15 / technical 0.15） - 三档 verdict：PASS ≥ 7.5 / RETRY 5-7.5 / REJECT < 5 - **可执行修复**：每个 issue 不写"光线不好"，直接给"add: golden hour rim light, soft fill from camera left" - 多图排名：`image_review.py a.png b.png c.png --rank` 自动批量评审排序 - 简评模式 `--quick`（只输出 overall_score，省 token） - 完整模式启用 prompt caching，多图调用省 90% input token ### C2: auto_iterate.py — 闭环自动迭代（新文件 350 行）把整个流程串成闭环： ``` enhance_prompt → render → image_review → 不达标？让 Claude 改 prompt → 回到第一步（≤ 3 轮） ``` - 9 个后端可选（DALL-E / SD-WebUI / ComfyUI / Replicate / Fal / 即梦 / 可灵 / 海螺） - 整轮锁定 seed，便于对比每轮的 prompt 改动到底改善了哪一维 - Claude 改 prompt 的 system prompt 单独设计，输入是上轮评审，输出是 revised_subject + extra_negatives + extra_mood + rationale - 每轮 trace 全保留（subject + recipe + image_path + review + revision），最终选最高分 - 用例： ```bash auto_iterate.py "持剑女侠" -p 赛博朋克 --backend dalle --target 7.5 --max-rounds 3 ``` ### C3: enhance_prompt.py 加 `--variants N`（A/B 测试） - 同 subject + 同 seed，仅在指定轴上分化 - 内置 4 维差异轴：mood / composition / lighting / stylize - `--variant-axes mood,composition` 选差异轴（默认这俩） - 用例： ```bash # 出 4 个变体（mood × composition 笛卡尔积取 4 个） enhance_prompt.py "持剑女侠" -p 赛博朋克 --variants 4 -j > variants.json # 出图后挑最优（用 image_review.py 排名） for f in renders/*.png; do echo "$f"; done | xargs image_review.py --rank ``` ### A1: 智能预设推荐 `--suggest` - 解决"温柔感"、"高级感"等模糊描述匹配不到预设的痛点 - 让 Claude 看用户描述 + 88 预设清单，返回 **top 3** 候选 - 每个候选附 score (0-1) + 一句话 reason + best_subject_example - 同时给 mix_suggestion（自动判断该不该混合） - 同时暴露在 `enhance_prompt.py --suggest` 和 `claude_polish.py --suggest` - 用例： ```bash enhance_prompt.py "温柔治愈感的画面" --suggest # → top_3: 疗愈治愈 / 奶油风 / 童话绘本，附理由 + 适合主体 ``` ### 兼容性 - 完全向下兼容 v2.4 - 新文件 `image_review.py` / `auto_iterate.py` 不影响老脚本 - 所有新参数有默认值 ### 文件改动 | 文件 | 改动 | |------|------| | `scripts/image_review.py` | 新文件 320 行 | | `scripts/auto_iterate.py` | 新文件 350 行 | | `scripts/enhance_prompt.py` | + 100 行（variants + suggest dispatch） | | `scripts/claude_polish.py` | + 90 行（suggest_presets 函数 + CLI） | | 其他 4 脚本 | VERSION bump | ### 真实差异化这一版做完，huo15-img-prompt 有了 GPT-4o image / Claude Imagen 都没有的能力： - **闭环反馈**：能告诉用户"这张图差在哪"+"下轮怎么改" - **可解释性**：5 维分项打分 + 改进 trace 全留 - **多模型协作**：Claude 评审 + DALL-E/Replicate/即梦出图，跨厂商组合 - **A/B 实验**：同 seed 控变量比较 --- ## v2.4.0 — 2026-04-27 **补齐 CLI 体验：扩 7 后端、prompt 压缩、参考图链接、多轮编辑。** ### B1+B2: render_prompt.py 扩 7 个后端 | 后端 | 环境变量 | 用例 | |------|---------|------| | `replicate` | `REPLICATE_API_TOKEN` | `--remote-model black-forest-labs/flux-schnell` | | `fal` | `FAL_KEY` | `--remote-model fal-ai/flux/schnell` | | `jimeng` | `ARK_API_KEY`（火山方舟） | 字节即梦 / Seedream 3.0 | | `kling` | `KLING_API_KEY` | 快手可灵 v1 | | `hailuo` / `minimax` | `MINIMAX_API_KEY` | 海螺 image-01 | 加上原有的 `comfyui` / `sd-webui` / `dalle` / `none(dry-run)`，**共 10 个后端**。 ### F2: enhance_prompt.py 加 `--compact` - 自动估算 prompt token 数（中文按字、英文按 1.3 token/word） - 超过 CLIP 77 token 触发压缩：去重 + 同义合并 + 按权重保留 - 必保头 6 段（主体 + camera 锁），尾部按预算砍 - 输出 `compaction` meta：before/after token 数、砍了几段 - 实测：v2.3 长 prompt 124 → 73 tokens（不损失主体） ### F1: enhance_prompt.py 加 `--examples` / `--with-examples` - 88 预设全量映射到搜索关键词（`PRESET_SEARCH_TERMS`） - 实时生成 5 平台搜索 URL：Lexica / Civitai / Pinterest / Google Images / Unsplash - 用法： - `enhance_prompt.py --examples 敦煌壁画` 单预设的 5 平台链接 - `enhance_prompt.py -l --with-examples` 列表模式带链接 - **零维护策略**：不内置静态图 URL，靠搜索 query 永远有效 ### A2: enhance_prompt.py 加 `--session` / `--continue` - 持久化目录 `~/.huo15/sessions/.json` - `--session catwindow` 保存当前调用 - `--continue catwindow` 加载历史 session 作为默认值，**自动锁定 seed** 保持多轮一致性 - CLI 参数 > session 默认值 > 系统默认（标准三层覆盖） - `--list-sessions` 列出全部历史 - 用例： ```bash # Turn 1 enhance_prompt.py "猫坐在窗台" -p 写实摄影 --session catwindow # Turn 2: 改画幅 + 加情绪，seed 自动锁定保证主体一致 enhance_prompt.py --continue catwindow --aspect 16:9 --mood 治愈 # Turn 3: 完全换主体描述但保 seed 测一致性 enhance_prompt.py "猫站起来伸懒腰" --continue catwindow ``` ### 兼容性 - 完全向下兼容 v2.3，所有新参数有默认值 - session 文件格式版本化（`name`/`iterations[]`/`latest`/`count`），未来扩字段不破坏老文件 ### 文件改动 | 文件 | 改动 | |------|------| | `scripts/enhance_prompt.py` | + 220 行（compaction + sessions + preset URLs） | | `scripts/render_prompt.py` | + 230 行（5 后端函数） | | 其他 4 脚本 | 仅 VERSION bump | --- ## v2.3.0 — 2026-04-26 **接入 Claude API + 平台合规润色，并起中文别名「火一五文生图提示词」。** ### 中文别名 `displayName: 火一五文生图提示词`，aliases 列表新增`火一五文生图提示词` 排第一位。 ### enhance_prompt.py — 加 --polish / --safety | 参数 | 作用 | |------|------| | `--polish` | 先调 Claude API（ANTHROPIC_API_KEY）智能润色，再走 88 预设增强 | | `--safety ` | 平台合规重写：DALL-E/MJ/SD/SDXL/Flux，自动把可能误判的艺术词替换 | 两者可叠加使用：先 polish 让 Claude 写出专业描述，再 safety 把误判词艺术化。 ### 新增脚本：claude_polish.py（350 行） - **Claude API 直调**：纯 urllib，不引入 anthropic SDK，避免企业扫描器 - **prompt caching 启用**：system prompt 用 `cache_control: ephemeral`，省 90% input token - **Prefill `{` + JSON 强约束**：assistant 起手 prefill 强制结构化输出 - **88 风格预设嵌入 system prompt**：让 Claude 从清单里挑而非凭记忆 - **XML 思维链**：内部 `` 让 Claude 分步骤思考（refine/style/camera/safety/negatives） - **Platform warnings**：Claude 主动识别 DALL-E/MJ/SD 各自的风险点并给出建议 - **--pipe**：输出可直接喂给 enhance_prompt.py 的 CLI 命令 ### 新增脚本：safety_lint.py（330 行） **仅服务合法艺术创作场景**，不做 jailbreak： ✗ 红线（直接拒答）： - CSAM（任何含未成年 + 性化的组合） - 真人 + 色情 / 政治污蔑 - 武器/毒品/爆炸物**制作方法/教程** - 自残/自杀**方法诱导** ✓ 黄区（艺术化重写）： - **violence**: 鲜血/血/伤口/kill/murder/weapon/gun/knife → crimson splash / battle-scarred / vanquish / ceremonial blade - **nudity**: naked/nude/裸/sexy → classical figure study / fine art reference / fashion editorial - **horror**: horror/scary/gore/monster/demon/evil → gothic atmospheric tension / mythical creature / dark fantasy - **death**: dead/corpse/skeleton/skull → memento mori / classical allegory / vanitas still life - **real-person**: celebrity/明星/actor/politician → fictional protagonist / 80s aesthetic - **brand**: marvel/disney/nike/iphone → superhero comic style / classic animated film / athletic sportswear - **weapon-model**: ak47/glock/uzi → fictional assault rifle prop 每词内置 `category` + `platforms_affected`。平台分级： - DALL-E `max` 严格度：所有黄区都触发高风险标记 - MJ `high` 中等：暴力/真人/品牌触发高风险 - SD/SDXL/Flux `low` 宽松（开源）：只对成人内容触发中风险输出三模式：默认人类可读 / `-j` JSON / `--apply` 直接输出重写文本（pipe 友好）。 ### 兼容性 - **完全向下兼容 v2.2**：所有新参数有默认值 - `--polish` 需 `ANTHROPIC_API_KEY`，未设置时报友好错误并不影响其他功能 - `--safety` 是纯本地词典，无网络依赖 ### 设计原则我们**坚决不做** jailbreak / 越狱 / 绕过模型对齐： - 仅做"合法艺术创作场景下的平台误判规避" - 红线检测优先于重写 - 替换词全部来自正规艺术、摄影、影视术语 - 用户输入红线内容时直接 `sys.exit(2)` 并给出改写建议 --- ## v2.2.0 — 2026-04-25 **四件套大版本：混合预设 + 视频提示词 + 参考图反解 + 直出图片。** ### 新增脚本 | 脚本 | 作用 | 关键参数 | |------|------|---------| | `enhance_prompt.py` | 文生图（升级） | `-p A+B --mix 0.6` | | `enhance_video.py` ⭐ | 视频提示词 | `-m Sora/Kling/Runway/Pika/Luma/Hailuo/即梦/Wan` | | `reverse_prompt.py` ⭐ | 参考图反解 | A1111 / ComfyUI / NovelAI metadata + VLM 模板 | | `render_prompt.py` ⭐ | 提示词直出 | `--backend comfyui/sd-webui/dalle/none` | ### enhance_prompt.py — 混合预设 - **`-p "A+B"` 语法**：`赛博朋克+水墨` / `原神+敦煌壁画` / `glassmorphism+wabisabi` 任意两两融合 - **`--mix `**：主预设权重 0.1-0.9（默认 0.6） - **SD 模式**：自动加权重语法 `(primary_tag:1.16), (secondary_tag:1.04)` - **MJ/Flux/通用**：按比例前置主预设标签 - **camera/lighting/palette 智能融合**：相机沿主预设、光影叠加、色板拼接、aspect 取主 - **PRESET_NEG_EXCLUDE 双向生效**：主辅任一需要 logo/text/signature 都会从 universal_neg 剔除 - **seed 锁定**：mix_label `A+B@0.60` 参与 hash，相同混合每次生成相同 seed ### enhance_video.py — 视频提示词（新文件 470 行） - **9 大视频模型规格**：Sora / Kling 可灵 / Runway Gen-3/4 / Pika / Luma DreamMachine / Hailuo MiniMax / 即梦 Seedance / 通义 Wan2.1 / 通用 - **30+ 镜头运动词典**：推/拉/摇/移/跟/环绕/手持/航拍/希区柯克/POV/子弹时间/延时/慢动作 ... - **9 节奏档位**：缓慢 / 宁静 / 中速 / 紧张 / 急促 / 快切 / 动感 / 史诗 ... - **30+ 主体动作自动抽词**：走/跑/跳/飞/舞/回眸/转身/挥剑/骑马/对视 ... - **关键帧三段式拆分**：开场建立 → 中段动作峰值 → 结尾落点 - **视频专属负面词**：flicker / motion blur artifacts / identity drift / morphing artifacts - **复用 88 风格预设 + 混合预设**：视觉锁完全沿用 image preset 体系 - **格式适配**：Pika 输出标签式，其他全部自然语言 ### reverse_prompt.py — 参考图反解（新文件 340 行） - **三层反解策略**： 1. **PNG metadata**：手写 PNG `tEXt`/`iTXt` 解析，零依赖（不引入 PIL） 2. **A1111/ComfyUI/NovelAI 三大格式自动识别**：parameters / prompt+workflow / Description+Comment 3. **VLM fallback 模板**：图无 metadata 时，输出标准化 88 预设选择 prompt 给 GPT-4o/Claude/Gemini/Qwen-VL - **启发式预设猜测**：35+ 关键词 → 预设映射（cyberpunk → 赛博朋克 / ghibli → 宫崎骏 / dunhuang → 敦煌壁画 ...） - **画幅自动推断**：从 size 字段算 ratio，匹配最近的 1:1/16:9/3:4/21:9 等 - **三种输出**：`text`(默认) / `--mj`(单行 MJ prompt) / `-j`(结构化 JSON 可 pipe) - **支持本地路径 + 远程 URL** ### render_prompt.py — 直出图片（新文件 270 行） - **4 个后端**： - `comfyui` — 本地 ComfyUI HTTP API（默认 http://127.0.0.1:8188） - `sd-webui` — AUTOMATIC1111 / Forge txt2img API（默认 http://127.0.0.1:7860） - `dalle` — OpenAI DALL-E 3（OPENAI_API_KEY） - `none` — dry-run，只输出 recipe JSON 不出图 - **零第三方依赖**：纯 urllib，避免企业扫描器命中 - **ComfyUI 默认 workflow**：内置 SDXL 9 节点 workflow，可用 `--workflow` 覆盖 - **环境变量覆盖**：`COMFYUI_URL` / `SDWEBUI_URL` - **支持混合预设直出** ### 新增功能矩阵 | 维度 | v2.1 | v2.2 | |------|------|------| | 出图前 | 提示词增强 | + **混合预设**（任意两两融合） | | 出图中 | （手工复制到模型） | + **直出**（comfyui/sd-webui/dalle） | | 出图后 | （无） | + **反解**（A1111/ComfyUI/NovelAI metadata） | | 视频 | （不支持） | + **视频提示词**（9 模型 + 关键帧 + 镜头运动） | ### 兼容性 - **完全向下兼容**：v2.1 所有 CLI 命令在 v2.2 不变；新参数均有默认值 - **JSON 字段新增**：`mix_secondary` / `mix_ratio` / `mix_label`（旧字段保留） - **enhance_video.py / reverse_prompt.py / render_prompt.py 是新文件**，不影响 enhance_prompt.py 老用户 ### 未变 - 88 风格预设、五锁机制、系列模式、角色设定图、质量档位 — 全部保留 --- ## v2.1.0 — 2026-04-24 **再扩充：更贴近需求 + 更多风格 + 角色一致性。** ### 新增风格预设（+32 款，总 56 → 88） - **游戏艺术（新类，7）**：原神 / 崩铁星穹 / 英雄联盟 / 暗黑4 / Valorant / Pokemon / 暴雪风 - **东方传统（新类，7）**：敦煌壁画 / 青花瓷 / 民国月份牌 / 年画 / 剪纸 / 和风 / 汉服写真 - **动漫扩展（+4）**：萌系 / 厚涂 / 轻小说封面 / 赛璐璐 - **现代设计（+6）**：玻璃拟态 / 新拟态 / 孟菲斯 / 杂志编排 / 包豪斯 / 奶油风 - **建筑氛围（+3）**：粗野主义 / 北欧极简 / 侘寂 - **摄影扩展（+3）**：暗黑美食 / 日杂 / 街头潮流 - **氛围综合（+2）**：疗愈治愈 / 美式复古 ### 新功能 - **角色设定图模式** `--character-sheet` / `-cs`： - 自动生成 T-pose + 正面 / 三分之二 / 侧面 / 背面多视图的设定图提示词 - 专为 Midjourney `--cref`、Stable Diffusion IP-Adapter 做角色参考用 - 画幅自动锁 16:9 - **时间 / 天气 / 季节自动抽词**： - 14 时间词：清晨 / 黎明 / 黄昏 / 日落 / 深夜 / 蓝调时刻 / 魔法时刻 ... - 15 天气词：晴天 / 下雨 / 暴雨 / 下雪 / 暴雪 / 雾天 / 雷雨 ... - 10 季节词：春夏秋冬 / 樱花季 / 枫叶季 - **负向需求识别**：识别主体描述中的"不要X / 没有X / 避免X / no X / avoid X / without X"，自动从正向提示中移除并加入负面提示。 - **质量档位** `-t basic / pro / master`： - `basic`: `high quality, detailed`（省 token） - `pro` (默认): `masterpiece, best quality, ultra detailed, 8k` - `master`: 叠加 `hdr, intricate details, sharp focus, award winning, trending on artstation, professional, highly polished` - **显式负面追加** `--avoid "cluttered, people"`：CLI 级附加负面词。 ### 新增别名（+45） `genshin` / `mihoyo` / `honkai` / `starrail` / `lol` / `diablo` / `valorant` / `pokemon` / `blizzard` / `overwatch` / `dunhuang` / `qinghua` / `porcelain` / `yuefenpai` / `wafu` / `hanfu` / `papercut` / `nianhua` / `moe` / `lightnovel` / `lncover` / `celshaded` / `glassmorphism` / `glass` / `neumorphism` / `memphis` / `editorial` / `bauhaus` / `cream` / `korean` / `brutalism` / `brutalist` / `nordic` / `scandinavian` / `wabisabi` / `zen` / `darkfood` / `muji` / `streetwear` / `hypebeast` / `healing` / `cozy` / `americana` ... ### 改进 - 主体描述中的"不要X"子句会先被 `strip_negative_clauses()` 去除再送入正向提示，避免正向污染。 - `print_prompt()` 输出增加 ⭐ 质量档位、👤 角色设定图模式、🕐 时间、☁️ 天气、🍂 季节、🚫 用户负向六个新字段展示。 - `list_presets()` 按 8 大类分类展示（新增"游戏" / "东方"分组）。 ### 兼容性 - **向下兼容**：v2.0 CLI 命令在 v2.1 完全可用，所有新参数均有默认值。 - **JSON 字段新增**：`quality_tier` / `character_sheet` / `time_of_day` / `weather` / `season` / `user_negatives`（旧字段保留）。 --- ## v2.0.0 — 2026-04-24 **大版本升级：一致性 + 贴近需求 + 风格扩充。** ### 新增 - **风格预设 17 → 56**，六大分类： - 摄影 10（新增：黑白摄影 / 人像摄影 / 时尚大片 / 美食摄影 / 微距摄影 / 航拍摄影 / 街拍纪实） - 动漫 6（新增：新海诚 / 宫崎骏 / 美漫 / Q版 / 童话绘本） - 插画 7（新增：工笔国画 / 浮世绘 / 线稿） - 3D 7（全部新增：3DC4D / 盲盒手办 / 低多边形 / 等距视图 / 粘土 / 毛毡手工 / 纸艺） - 设计 10（新增：平面设计 / Logo设计 / 图标设计 / 信息图 / 品牌KV / 专辑封面 / 电影海报 / 表情包） - 艺术史 4（全部新增：印象派 / 后印象派 / 新艺术 / 装饰艺术） - 场景氛围 12（新增：黑暗奇幻 / Y2K / Vaporwave / 霓虹灯牌 / 概念艺术） - **一致性四锁**：每个预设内置 `camera` / `lighting` / `palette` / `aspect` 四项独立锁，系列出图风格不再漂移。 - **系列批量模式** `-s N --variations "A,B,C,D"`：共享 seed + 四锁，主体描述差异化，一次生成一整套。 - **意图识别器**：无需指定 `-p`，脚本从"logo/产品/海报/头像/美食/赛博/水墨..."等关键词自动推荐预设 + 画幅。 - **构图/情绪抽词**：主体描述中的"俯拍/特写/航拍/神秘/温馨/史诗..."自动并入提示词。 - **稳定 seed 建议**：基于 `md5(subject + preset)` 生成 32-bit seed，便于复现。 - **英文 / 同义词别名**：60+ 别名（anime、ghibli、cyberpunk、minimal、3d、logo、neon、vapor…）。 - **多模型精细化适配**： - Midjourney 输出 `--ar --stylize`，提示 `--cref/--sref` - Stable Diffusion 输出权重语法 `(subject:1.2)`，提示采样器/CFG - SDXL 输出推荐尺寸（`1216x832` 等） - Flux 输出长句自然语言 + guidance 提示 - DALL-E 3 输出段落式自然语言 - **JSON 输出** `-j`：结构化一致性锁 + 所有参数，便于下游集成。 - **CLI 增强**：`-a/--aspect`、`--mood`、`--composition`、`--seed`、`-l/--list`、`-v/--version`。 ### 修复 - 修复 Logo设计 / 图标设计 / 表情包 / 海报等预设的**全局负面词包含 "logo/text"** 导致的语义自我否定。 - 修复水墨 / 工笔国画 / 浮世绘预设中**负面词包含 "signature"** 与画面印章冲突。 ### 破坏性变更 - `build_prompt()` 返回 dict 新增 `aspect` / `seed_suggestion` / `consistency_lock` / `hint` / `version` 字段（向下兼容，原有字段保留）。 --- ## v1.0.0 — 2026-04-24（初始版本） - 17 风格预设（写实摄影 / 胶片摄影 / 动漫 / 赛博朋克 / 水彩 / 油画 / 建筑可视化 / 产品设计 / 像素艺术 / 奇幻 / 科幻 / 复古海报 / 水墨 / 蒸汽朋克 / 极简主义 / 电影感 / 国潮）。 - 支持 Midjourney / SD / DALL-E / 通用四种输出骨架。 - CLI：`subject -p -m [-l] [-j]`。 FILE:QUICKSTART.md # 快速上手 — 三层级 > 30 秒 / 5 分钟 / 30 分钟，按你想投入的时间往下读。 ## 0. 首次安装后先跑这个 ```bash python3 scripts/doctor.py --quick ``` 会告诉你： - 14 个脚本是否都能 import + 版本是否一致 - 哪些 API key 已配 / 缺哪些（按需） - Obsidian vault 检测到没 - 持久化资产盘点（characters / sessions / brand_kits / learned_presets）如果看到 `✗ ANTHROPIC_API_KEY 未设置（必填）`，先： ```bash export ANTHROPIC_API_KEY=sk-ant-xxx # 把 sk-ant-xxx 换成你的真实 key # 或写到 ~/.zshrc / ~/.bashrc ``` --- ## 30 秒：第一条命令 ```bash scripts/enhance_prompt.py "一只赛博朋克的猫" -p 赛博朋克 -m Midjourney ``` 复制 `✅ 正向提示词` 那段，粘贴到 Midjourney/Discord，回车出图。完了，就这么简单。 --- ## 5 分钟：基础工作流 ### Step 1: 选预设（不知道选哪个 → 让 Claude 推荐） ```bash scripts/enhance_prompt.py "温柔治愈感的画面" --suggest ``` Claude 会从 88 预设里挑 top 3，附评分 + 适合场景。 ### Step 2: 出图 ```bash # 基础（自己挑预设） scripts/enhance_prompt.py "咖啡馆窗边的少女" -p 胶片摄影 -m Midjourney # 混合两种风格（v3.0 特性） scripts/enhance_prompt.py "持剑女侠" -p "赛博朋克+水墨" --mix 0.6 -m SDXL # A/B 测试出 4 个变体（同 seed，不同 mood/composition） scripts/enhance_prompt.py "夜晚街景" -p 电影感 --variants 4 -j > /tmp/variants.json ``` ### Step 3: 保存常用资产 ```bash # 角色卡（跨调用保持一致） scripts/enhance_prompt.py "银发机甲少女, twin tails, glowing visor" \ -p 动漫 --character-sheet --save-char silver_mecha # 后续直接用 scripts/enhance_prompt.py "在霓虹街头" --char silver_mecha scripts/enhance_prompt.py "在花海中" --char silver_mecha # → 自动锁 seed，三张图角色一致 ``` ### Step 4: 看预设示例图 ```bash scripts/enhance_prompt.py --examples 敦煌壁画 # 输出 5 平台搜索 URL（Lexica / Civitai / Pinterest / Google / Unsplash） ``` --- ## 30 分钟：完整工作流 ### A. 端到端品牌 KV（食谱 1） ```bash # 1. 导入示例品牌套件 cat examples/brand_kit-song_tea.json | scripts/brand_kit.py --import # 2. 用品牌套件 + 智能润色 + 闭环迭代 scripts/auto_iterate.py "宋韵茶饮品牌主视觉，一杯热茶，远山轮廓" \ -p "汉服写真+水墨" \ --backend dalle \ --target 7.5 \ --max-rounds 3 # → Claude Vision 五维评审，分数 < 7.5 自动改 prompt 重出 ``` ### B. 学习自己喜欢的风格 ```bash # 给 N 张参考图（你自己拍的、收藏的） scripts/style_learn.py --name 我的小清新 \ refs/morning_cafe.jpg \ refs/sunset.jpg \ refs/quiet_corner.jpg \ refs/film_kodak.jpg # 后续用 @ 前缀调用 scripts/enhance_prompt.py "猫咪坐在窗台" -p "@我的小清新" ``` ### C. 短片故事板（v3.0 杀手 feature） ```bash # 输入剧本 → Claude 拆 6 关键帧 + 5 个转场 scripts/storyboard.py < examples/storyboard-cat_rainy_night.txt \ -p 电影感 --scenes 6 \ -m Midjourney --video-model Sora \ --output ./renders/cat_rainy_night ``` 输出（在 `./renders/cat_rainy_night/`）： - `storyboard.json` 完整数据 - `scene-{01-06}-t2i.txt` 6 个关键帧 T2I prompt - `transition-{xx-to-yy}-t2v.txt` 5 个转场 T2V prompt - `README.md` 可读总览把 6 个 scene prompt 喂 Midjourney，5 个 transition prompt 喂 Sora，剪辑串联即得 ~30 秒短片。 ### D. 在 IDE 里直接用（Claude Code / Cursor）注册到 `~/.claude/mcp.json`： ```json { "mcpServers": { "huo15-img-prompt": { "command": "python3", "args": ["/path/to/huo15-img-prompt/scripts/mcp_server.py"] } } } ``` 然后在 Claude Code： ``` > @huo15-img-prompt 帮我给落地页做 hero 图，主题是"AI 编程助手"，要科技感但温暖 ``` Claude Code 会自动调链路：suggest_presets → polish_prompt → enhance_prompt → review_image。 ### E. 本地 Web UI ```bash python3 scripts/web_ui.py # 自动开浏览器到 http://127.0.0.1:7155 ``` 可视化 88 预设、实时 prompt 预览、一键复制。 ### F. 把 recipe 沉淀到 Obsidian ```bash scripts/enhance_prompt.py "..." --obsidian # 自动写入 ~/knowledge/huo15/图集/ 或 OBSIDIAN_VAULT 指定位置 # 含完整 frontmatter + 复现命令 ``` --- ## 常见问题 ### Q1: 我没有 ANTHROPIC_API_KEY，能用吗？可以。**80% 功能不依赖 Claude**： - ✅ enhance_prompt（88 预设 / 五锁 / 混合 / variants / compact） - ✅ enhance_video（视频提示词） - ✅ reverse_prompt（参考图反解，metadata 模式） - ✅ render_prompt（10 后端直出，需要对应后端的 key） - ✅ safety_lint（红线检测，纯本地词典） - ✅ character / brand_kit（持久化） - ✅ web_ui / mcp_server 需要 ANTHROPIC_API_KEY 的： - ❌ claude_polish（智能润色） - ❌ image_review（VLM 评审） - ❌ auto_iterate（闭环迭代） - ❌ storyboard（剧本拆分） - ❌ style_learn（风格学习） - ❌ --suggest 推荐预设 ### Q2: 我能在 Anaconda 环境里用吗？可以，纯标准库，没有第三方依赖。任何 Python 3.8+ 环境都行。 ### Q3: 哪些后端最值得配？ - **入门**：DALL-E 3（OPENAI_API_KEY，质量稳定，文字渲染好） - **省钱**：本地 ComfyUI / SD WebUI（一次性下载模型，永久免费） - **国产场景**：字节即梦（ARK_API_KEY，中文场景效果好） - **快速试**：Replicate flux-schnell（REPLICATE_API_TOKEN，4 步出图） ### Q4: 14 个脚本太多，我从哪 3 个开始？ 1. `enhance_prompt.py` — 这是核心，所有路径都从它开始 2. `doctor.py` — 出问题先跑这个 3. `web_ui.py` — 不想敲命令的时候用剩下的按需：要出图 → render_prompt；要短片 → storyboard；要做品牌一致 → brand_kit。 ### Q5: 出来的 prompt 太长，SDXL 会截断怎么办？ ```bash scripts/enhance_prompt.py "..." -m SDXL --compact # 自动压缩到 CLIP 77 token 内 ``` ### Q6: 我之前的图想改一改，prompt 丢了 ```bash scripts/reverse_prompt.py 你的图.png # 自动从 PNG metadata 提取 A1111/ComfyUI/NovelAI 三种格式的 prompt ``` 如果图没 metadata： ```bash scripts/reverse_prompt.py 你的图.png --vlm # 输出标准 VLM 模板，复制给 GPT-4o / Claude Sonnet 4.5 / Gemini 即可 ``` --- ## 下一步 - 完整 88 预设：`scripts/enhance_prompt.py -l --with-examples` - 食谱书：[RECIPES.md](RECIPES.md) - 完整 CLI：每个脚本都有 `-h` / `--help` 有问题先跑 `doctor.py`，再到 [https://clawhub.ai/skills/huo15-img-prompt](https://clawhub.ai/skills/huo15-img-prompt) 看 issue。 FILE:RECIPES.md # 火一五创意生态 — 整合食谱 > v3.0 加入 huo15 创意生态后，huo15-img-prompt 不再是独立工具，而是「创意管线」的核心节点。 > 本文档列出和其他 huo15-openclaw-* 技能的串联用法。 ## 火一五创意全家桶 | 技能 | 角色 | |------|------| | `huo15-openclaw-design-director` | 选设计方向（5 流派 × 20 哲学 → 3 方向反差对比） | | `huo15-openclaw-brand-protocol` | 抓品牌规范（Ask/Search/Download/Verify/Codify） | | `huo15-openclaw-frontend-design` | 高保真 Web UI 落地 + 设计 tokens | | `huo15-openclaw-design-critique` | 5 维设计评审 + Keep/Fix/Quick Wins | | **`huo15-img-prompt`** ⭐ | 文生图 + 文生视频 + 闭环迭代 | --- ## 食谱 1：从零到一做品牌 KV（key visual） ``` 设计方向 → 品牌规范 → 出图 → 评审 → 落地 ``` ### Step 1: design-director 选方向 ``` > 我要做一个茶饮品牌，希望有东方气质但又年轻 ``` → design-director 给 3 个反差对比方向（如：宋韵极简 / 国潮复古 / 禅意新中式）。 ### Step 2: brand-protocol 沉淀品牌规范选定"宋韵极简"后： ``` > 帮我把这个方向 codify 成 brand kit ``` → brand-protocol 输出：colors / fonts / visual_keywords / forbidden 元素。导入 huo15-img-prompt： ```bash brand-protocol-output.json | brand_kit.py --import # 或手动创建 brand_kit.py --create song_tea \ --colors "#2C5F2D, #97BC62, #F7F4EA" \ --fonts "Songti SC, Source Han Serif" \ --keywords "宋韵, 极简, 留白, 文人画" \ --forbidden "modern digital, neon, cyberpunk" ``` ### Step 3: img-prompt 出 KV 图 ```bash # 用品牌套件 + 推荐预设 enhance_prompt.py "茶饮品牌主视觉, 一杯热茶, 远山" \ -p "汉服写真+水墨" \ --brand-kit song_tea \ --polish # Claude 智能润色 # 或闭环迭代到 7.5 分 auto_iterate.py "茶饮品牌主视觉" \ -p "汉服写真+水墨" \ --backend dalle \ --target 7.5 ``` ### Step 4: design-critique 评审 ``` > 用 design-critique 评审这套图 ``` → Keep/Fix/Quick Wins 三分类反馈。 ### Step 5: frontend-design 落地把出图作为 hero 图，调用 frontend-design 生成完整官网： ``` > 用 frontend-design 给这个茶饮品牌做落地页，hero 用上面这张 KV ``` → 完整 HTML/CSS/JS 原型，沿用 brand kit 的 tokens。 --- ## 食谱 2：自学习风格 + 角色一致性 + 视频短片适合个人 IP / 自媒体内容创作。 ### Step 1: style_learn 学习独有风格收集你喜欢的 5-10 张图（自己拍的、收藏的、参考的）： ```bash style_learn.py --name 我的小清新 \ refs/morning_cafe.jpg \ refs/sunset_seoul.jpg \ refs/film_kodak.jpg \ refs/window_light.jpg \ refs/quiet_corner.jpg ``` → Claude Vision 综合 5 张图共性 → 生成 learned preset `@我的小清新`。 ### Step 2: character 创建固定角色 ```bash enhance_prompt.py "20 岁亚裔女孩, 长直发, 圆框眼镜, 米白毛衣" \ -p "@我的小清新" \ --character-sheet \ --save-char 我的女主 ``` ### Step 3: storyboard 拆短片剧本 ```bash storyboard.py "女主在咖啡馆度过的下雨午后，从写信到收到回信" \ -p "@我的小清新" \ --scenes 6 \ -m Midjourney \ --video-model Sora \ --output ./my_story ``` → 6 个关键帧 + 5 个转场，每个都 prompt 完整可用。 ### Step 4: 出图 + 出视频 ```bash # 关键帧用 Midjourney 出 for f in my_story/scene-*-t2i.txt; do cat $f | grep -A1 '## Positive' | tail -1 # 喂给 MJ done # 转场用 Sora 出（关键帧作为首帧） for f in my_story/transition-*.txt; do # 喂给 Sora i2v 模式 done # 剪辑串联即得短片 ``` ### Step 5: 评审反馈 ```bash image_review.py my_story/renders/*.png --rank ``` 不好的轮次让 auto_iterate 自动改。 --- ## 食谱 3：电商商品图全套 ### Step 1: brand_kit 沉淀品牌色 ```bash brand_kit.py --create my_brand \ --colors "#FF6B35, #1A1A2E, #FAFAFA" \ --keywords "清爽, 现代, 高级感" ``` ### Step 2: 用变体测试找最优 prompt ```bash enhance_prompt.py "无线耳机产品图, 白底, 30 度俯视" \ -p 产品摄影 \ --brand-kit my_brand \ --variants 6 \ --variant-axes mood,composition,lighting # 出 6 张图后排名 image_review.py renders/variant-*.png --rank ``` ### Step 3: 锁定最优 → 系列扩展最优变体的 seed → 用作角色卡： ```bash enhance_prompt.py "无线耳机产品图" \ -p 产品摄影 \ --brand-kit my_brand \ --save-char earphone_main \ --seed <最优 seed> # 后续所有变体（不同角度、配件、场景）共用 enhance_prompt.py "无线耳机展示图，环境光" --char earphone_main enhance_prompt.py "无线耳机加包装" --char earphone_main enhance_prompt.py "无线耳机使用场景" --char earphone_main ``` ### Step 4: 沉淀到 Obsidian ```bash enhance_prompt.py "..." --char earphone_main --obsidian ``` → 所有 recipe 写入 vault `图集/`，方便后续团队 review。 --- ## 食谱 4：Claude Code 工作流（IDE 内调用）注册 MCP server 到 `~/.claude/mcp.json`： ```json { "mcpServers": { "huo15-img-prompt": { "command": "python3", "args": ["/path/to/huo15-img-prompt/scripts/mcp_server.py"] } } } ``` 然后在 Claude Code 里： ``` > @huo15-img-prompt 帮我给落地页做一张 hero 图，主题是"AI 编程助手"，要科技感但温暖 ``` Claude Code 会： 1. 调 `suggest_presets` 推荐 top-3 2. 调 `polish_prompt` 润色 3. 调 `enhance_prompt` 出 prompt 4. 你出图后调 `review_image` 五维评审 5. 不好让 Claude 改 prompt 重出（闭环） --- ## 食谱 5：和 huo15-openclaw-knowledge-base 联动把 brand_kit + character_card + learned_preset 沉淀到 huo15 知识库： ```bash # brand_kit 导出 → 入库 brand_kit.py --export song_tea | jq '.' > raw/song_tea_brand.json # 然后用 knowledge-base 编译入 wiki # character 导出 → 入库 character.py --export 我的女主 > raw/heroine.json ``` → wiki 全局搜索时这些资产可被检索。 --- ## 设计原则 1. **每个技能管自己一段**：design-director 选方向，img-prompt 出图，design-critique 评审 2. **数据格式互通**：brand_kit / character / learned_preset 都是标准 JSON，可在技能间传递 3. **Claude 是协调者**：用 Claude Code + MCP 让 Claude 自动选择合适的技能链路 4. **闭环优先**：每一步都有"评审 → 改 → 重做"的能力，不要单步走到底 ## 反对的做法 ❌ 把所有功能塞到一个技能里（违反"每个 skill 独立模块化"原则） ❌ 在 img-prompt 里复刻 design-director 的方向选择能力（重复造轮子） ❌ 不沉淀 brand_kit / character / learned_preset 到 ~/.huo15/（每次重新生成） ❌ 跳过评审直接发布（v2.5 的闭环迭代是免费的，不用白不用） --- 由 huo15-img-prompt v3.0 发布，后续随生态扩展持续更新。 FILE:_meta.json { "ownerId": "kn7byevkn40d6z4p7ghdb097z983tj33", "slug": "huo15-img-prompt", "version": "3.1.0" } FILE:examples/README.md # 示例素材直接可用的 brand kit / character / learned preset / 剧本，导入即用。 ## 文件清单 | 文件 | 类型 | 用途 | |------|------|------| | `brand_kit-song_tea.json` | 品牌套件 | 宋韵东方茶饮品牌示例 | | `character-silver_mecha.json` | 角色卡 | 银发机甲少女（演示跨调用一致性） | | `learned_preset-fresh_film.json` | 学习预设 | 清新胶片风（日杂感） | | `storyboard-cat_rainy_night.txt` | 剧本 | 一只猫的雨夜散步（6 帧） | | `recipe-1-brand_kv.sh` | Bash 脚本 | RECIPES.md 食谱 1 的可运行版 | ## 导入方式 ```bash # Brand kit cat examples/brand_kit-song_tea.json | scripts/brand_kit.py --import scripts/brand_kit.py --show song_tea # 角色卡 cat examples/character-silver_mecha.json | scripts/character.py --import scripts/character.py --show silver_mecha # Learned preset（直接复制到目录即可） mkdir -p ~/.huo15/learned_presets cp examples/learned_preset-fresh_film.json ~/.huo15/learned_presets/ # 用 learned preset 出图 scripts/enhance_prompt.py "咖啡馆窗边少女" -p "@fresh_film" # 故事板 scripts/storyboard.py < examples/storyboard-cat_rainy_night.txt \ -p 电影感 --scenes 6 --output ./renders/cat_rainy_night # 完整食谱 1 bash examples/recipe-1-brand_kv.sh ``` ## 自定义指南复制示例文件改字段即可： - **brand_kit**：改 `colors / fonts / keywords / forbidden / logo_description` - **character**：改 `subject_description / preset / aspect / seed` - **learned_preset**：建议用 `style_learn.py --name 你的风格 ref*.jpg` 自动生成，不要手写 ## 反对的做法 ❌ 手写 learned_preset.json — confidence 字段是 Claude 综合后的可信度，手写会失真 ❌ 直接改示例文件 — 应该导入后用 `--update` 修改自己的副本 ❌ 把 example 当生产数据 — 仅供参考，按业务场景重新建立 FILE:examples/brand_kit-song_tea.json { "name": "song_tea", "version": "3.1.0", "description": "宋韵东方茶饮品牌套件示例 — 用于 RECIPES.md 食谱 1", "colors": [ "#2C5F2D", "#97BC62", "#F7F4EA", "#3E2723" ], "fonts": [ "Songti SC", "Source Han Serif", "Noto Serif CJK SC" ], "keywords": [ "宋韵", "极简", "留白", "文人画", "山水意境", "克制" ], "forbidden": [ "modern digital", "neon", "cyberpunk", "harsh contrast", "saturated cartoon" ], "logo_description": "minimal seal-script chinese character on parchment", "use_count": 0 } FILE:examples/character-silver_mecha.json { "name": "silver_mecha", "version": "3.1.0", "description": "示例角色卡：银发机甲少女 — 用于演示 --char 跨调用一致性", "use_count": 0, "subject_description": "银发双马尾机甲少女，发光面甲，藏青色机甲战衣，轮廓发光线条", "preset": "动漫", "mix_secondary": "", "mix_ratio": null, "aspect": "16:9", "seed": 1154904041, "camera": "low angle hero shot, 50mm portrait lens, shallow depth of field", "lighting": "anime-style soft light, rim light on hair, glowing visor accent", "palette": "vibrant saturated anime palette, silver and deep navy, neon cyan accents", "is_character_sheet": true, "positive_anchor": "silver-haired twin-tails mecha girl, glowing visor, navy mecha armor" } FILE:examples/learned_preset-fresh_film.json { "name": "fresh_film", "version": "3.1.0", "description": "示例 learned preset：清新胶片风格 — 用于演示 -p '@fresh_film' 调用", "created_at": 1745000000, "use_count": 0, "category": "学习", "tags": "kodak portra 400 film stock, soft natural light, muted earth tones, hazy atmospheric, lifestyle photography, japanese magazine aesthetic", "quality": "raw photo, fine grain, scanned film, masterpiece, best quality", "neg": "harsh contrast, oversaturated, hdr, plastic skin, digital sharpness, neon", "camera": "35mm film camera, 50mm prime, shallow depth of field, slight handheld feel", "lighting": "soft window light, golden hour rim, slightly underexposed, natural ambient fill", "palette": "muted earth tones, faded film colors, sage green, warm cream, soft blush", "aspect": "3:2", "synthesis_notes": "日杂感的清新胶片风：自然光、克制色彩、留白构图、低饱和高级感", "best_subject_examples": [ "咖啡馆里的窗边少女", "雨后湿漉漉的窗台", "夏末的乡村小路" ], "confidence": 0.85, "source_count": 5, "source_images": [ "(示例文件，源图省略)" ] } FILE:examples/recipe-1-brand_kv.sh #!/bin/bash # 示例食谱 1：从零到一做品牌 KV # 配合 RECIPES.md 食谱 1。运行前确保已配置 ANTHROPIC_API_KEY + OPENAI_API_KEY。 # # 这个脚本演示完整工作流： # 导入 brand_kit → polish → variants 出 4 个候选 → image_review 排名 → 闭环迭代到 7.5 分 set -e SCRIPTS_DIR="$(dirname "$0")/../scripts" EXAMPLES_DIR="$(dirname "$0")" echo "━━━ Step 1: 导入示例 brand_kit ━━━" cat "$EXAMPLES_DIR/brand_kit-song_tea.json" | python3 "$SCRIPTS_DIR/brand_kit.py" --import echo echo "━━━ Step 2: Claude 智能润色（建议预设） ━━━" python3 "$SCRIPTS_DIR/claude_polish.py" "宋韵茶饮品牌主视觉，一杯热茶，远山轮廓" --suggest echo echo "━━━ Step 3: 出 4 个 A/B 变体（同 seed 不同 mood/composition） ━━━" python3 "$SCRIPTS_DIR/enhance_prompt.py" \ "宋韵茶饮品牌主视觉，一杯热茶，远山轮廓" \ -p "汉服写真+水墨" \ --brand-kit song_tea \ --variants 4 \ -j > /tmp/variants.json echo "已写入 /tmp/variants.json，含 4 个变体的完整 prompt" echo echo "━━━ Step 4（需要 ANTHROPIC + 后端）: 闭环自动迭代到 7.5 分 ━━━" echo "下一步真正出图（需要 OPENAI_API_KEY）：" cat <`（MJ）或 IP-Adapter（SD/ComfyUI）即可得到风格完全一致的一套产品图。 ### 场景：出一套角色立绘 ```bash ./scripts/enhance_prompt.py "银发机甲少女" -p 动漫 -s 6 \ --variations "正面站立,侧面剪影,奔跑姿势,持武器pose,受伤后,胜利姿态" \ -m Midjourney ``` 记得在 MJ 里给第一张做 `--cref`，后续 5 张引用同一 URL，角色脸部 95%+ 一致。 ## 七、Prompt 写作红线 - ❌ 英文提示词里**堆砌中文地名**（除非模型是中文 checkpoint） - ❌ 一次塞超过 **8 个并列风格**（风格冲突 → 画面混乱） - ❌ 把**颜色描述**堆得比主体还多（模型会优先表现颜色忽略主体） - ❌ 负面词**过长**（SD 负面超过 75 tokens 后生效打折） - ✅ 主体用英文、风格用英文、地域/文化用英文（例 "Chinese traditional garden"） - ✅ 想要稳定输出：用预设 + seed 锁；想要探索：去 seed / 加 `--chaos 30` FILE:scripts/auto_iterate.py #!/usr/bin/env python3 """ huo15-img-prompt — 闭环自动迭代 v2.5 把 enhance_prompt + render_prompt + image_review 串成闭环：生成 → 出图 → 评审 → 不达标？让 Claude 改 prompt 再来一轮（≤ 3 轮）这是 v2.5 的核心护城河：GPT-4o image / Imagen / Claude Imagen 内部都做不到，因为它们的 prompt 是黑盒。我们在用户侧补这个反馈循环。工作流（每轮）： Step 1: enhance_prompt 生成 recipe（首轮用基础推荐，后续用上轮 fix 后的） Step 2: render_prompt 出图（任意 backend） Step 3: image_review 五维评审 Step 4: overall_score >= target_score → 完成 < target_score 且 attempt < max_attempts: → 用 Claude 把 actionable_fixes 综合成新 prompt → 回 Step 1 Step 5: 返回历史最高分图 + 全过程 trace 调用： auto_iterate.py "持剑女侠" -p 赛博朋克 --backend dalle --target 7.5 auto_iterate.py "汉服少女" -p 汉服写真 --backend jimeng --max-rounds 3 auto_iterate.py "敦煌神女" -p 敦煌壁画 --backend none --no-render # 评审现有 recipe，不真出图依赖： - 同目录 enhance_prompt.py / render_prompt.py / image_review.py - ANTHROPIC_API_KEY（评审 + 改 prompt） - 后端对应的 API key（DALL-E / Replicate / 即梦 / 可灵等） """ import sys import os import json import time import argparse from typing import Dict, List, Optional from urllib.request import Request, urlopen from urllib.error import HTTPError sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) from enhance_prompt import ( build_prompt, parse_mix_preset, resolve_preset, parse_requirement, STYLE_PRESETS, ASPECT_TO_SDXL, ) from image_review import review_image, parse_review_json, ANTHROPIC_BASE, ANTHROPIC_VERSION VERSION = "3.1.0" DEFAULT_MODEL = "claude-sonnet-4-5" DEFAULT_TARGET_SCORE = 7.5 DEFAULT_MAX_ROUNDS = 3 # ───────────────────────────────────────────────────────── # Claude 改 prompt（基于上轮评审） # ───────────────────────────────────────────────────────── REVISION_SYSTEM_PROMPT = """你是 prompt revision 专家，给定一张图的 5 维评审，输出改进版 prompt。 # 工作流 1. 读 actionable_fixes（按优先级，high 必处理） 2. 读 issues（避免下轮重蹈覆辙） 3. 读 good_points（保留这些优势） 4. 输出新 prompt（只输出主体描述部分，不要带 style/camera/lighting 模板，因为 enhance_prompt.py 会再加这些锁） # 输出 JSON 严格 schema ```json { "revised_subject": "改进后的主体描述（中文，可加视觉细节），喂给 enhance_prompt.py 的 subject 参数", "preset_change": null, "extra_negatives": ["补充负面词 1", "补充负面词 2"], "extra_mood": "如需更改情绪覆盖（无则空）", "extra_composition": "如需更改构图覆盖（无则空）", "rationale": "中文一句话说明这次改动针对哪个维度的 issue" } ``` `preset_change` 只在评审里明确说"风格不对"时改，否则保持 null。只输出 JSON，不要解释。""" def call_claude_revise(original_subject: str, original_preset: str, review: Dict, model: str = DEFAULT_MODEL) -> Dict: """让 Claude 基于 review 输出改进 subject。""" api_key = os.environ.get("ANTHROPIC_API_KEY") if not api_key: raise RuntimeError("缺少 ANTHROPIC_API_KEY") review_summary = { "overall_score": review.get("overall_score", 0), "verdict": review.get("verdict", "?"), "summary": review.get("summary", ""), "actionable_fixes": review.get("actionable_fixes", []), "weak_dimensions": [], } for dim in ("subject_match", "composition", "lighting", "palette", "technical"): d = review.get(dim, {}) score = d.get("score", 0) if score < 7: review_summary["weak_dimensions"].append({ "dim": dim, "score": score, "issues": d.get("issues", []), }) user_msg = f""" subject: {original_subject} preset: {original_preset} {json.dumps(review_summary, ensure_ascii=False, indent=2)} 请输出改进后的 JSON。""" body = { "model": model, "max_tokens": 1500, "system": [{ "type": "text", "text": REVISION_SYSTEM_PROMPT, "cache_control": {"type": "ephemeral"}, }], "messages": [ {"role": "user", "content": user_msg}, {"role": "assistant", "content": "{"}, ], } req = Request( f"{ANTHROPIC_BASE}/v1/messages", data=json.dumps(body).encode("utf-8"), headers={ "Content-Type": "application/json", "x-api-key": api_key, "anthropic-version": ANTHROPIC_VERSION, }, method="POST", ) try: with urlopen(req, timeout=60) as r: resp = json.loads(r.read().decode("utf-8")) except HTTPError as e: raise RuntimeError(f"Claude HTTP {e.code}: {e.read().decode('utf-8', errors='replace')}") return parse_review_json(resp) # ───────────────────────────────────────────────────────── # 后端调用（直接 import render_prompt 函数，不重复实现） # ───────────────────────────────────────────────────────── def render_via_backend(backend: str, recipe: Dict, aspect: str, output_dir: str, remote_model: str = "", steps: int = 25, cfg: float = 7.0) -> Dict: """统一 backend dispatch，复用 render_prompt 内部函数。""" from render_prompt import ( render_dalle, render_sdwebui, render_comfyui, render_replicate, render_fal, render_jimeng, render_kling, render_hailuo, DALLE_SIZES, ) seed = recipe["seed_suggestion"] pos, neg = recipe["positive"], recipe["negative"] if backend == "dalle": size = DALLE_SIZES.get(aspect, "1024x1024") return render_dalle(pos, size, output_dir) elif backend == "sd-webui": return render_sdwebui(pos, neg, aspect, seed, steps, cfg, "DPM++ 2M Karras", output_dir) elif backend == "comfyui": return render_comfyui(pos, neg, aspect, seed, steps, cfg, None, output_dir) elif backend == "replicate": ref = remote_model or "black-forest-labs/flux-schnell" return render_replicate(pos, neg, aspect, seed, ref, output_dir, steps=steps, cfg=cfg) elif backend == "fal": ref = remote_model or "fal-ai/flux/schnell" return render_fal(pos, neg, aspect, seed, ref, output_dir, steps=steps) elif backend == "jimeng": return render_jimeng(pos, neg, aspect, seed, output_dir) elif backend == "kling": return render_kling(pos, neg, aspect, seed, output_dir) elif backend in ("hailuo", "minimax"): return render_hailuo(pos, neg, aspect, seed, output_dir) else: raise RuntimeError(f"未知 backend: {backend}") # ───────────────────────────────────────────────────────── # 闭环主流程 # ───────────────────────────────────────────────────────── def auto_iterate( subject: str, preset: str, backend: str, target_score: float = DEFAULT_TARGET_SCORE, max_rounds: int = DEFAULT_MAX_ROUNDS, aspect: str = "", model_adapt: str = "SDXL", output_dir: str = "./renders", remote_model: str = "", no_render: bool = False, quality_tier: str = "pro", seed: Optional[int] = None, ) -> Dict: """主闭环。返回 trace + 最佳轮次。""" primary_raw, secondary_raw = parse_mix_preset(preset) if secondary_raw: primary = resolve_preset(primary_raw) secondary = resolve_preset(secondary_raw) if not primary or not secondary: raise RuntimeError(f"未知预设: {primary_raw} 或 {secondary_raw}") preset_resolved, mix_secondary = primary, secondary else: preset_resolved, mix_secondary = (resolve_preset(primary_raw) or "写实摄影"), None auto = parse_requirement(subject) if not aspect: aspect = auto["aspect_suggestion"] or STYLE_PRESETS.get(preset_resolved, {}).get("aspect", "1:1") rounds: List[Dict] = [] current_subject = subject current_extra_neg = "" current_mood = "" current_composition = "" locked_seed = seed # 整轮锁同一 seed，便于对比 for attempt in range(1, max_rounds + 1): print(f"\n🔄 第 {attempt}/{max_rounds} 轮...", file=sys.stderr) recipe = build_prompt( current_subject, preset_resolved, model_adapt, aspect, extra_mood=current_mood, extra_composition=current_composition, extra_negatives=current_extra_neg, seed=locked_seed, quality_tier=quality_tier, mix_secondary=mix_secondary, ) if locked_seed is None: locked_seed = recipe["seed_suggestion"] round_data = {"attempt": attempt, "subject": current_subject, "recipe": recipe} if no_render: print(f" 🧪 dry-run 模式：不出图，仅评审 prompt 文本（跳过本轮，需 --no-render 配合外部出图）", file=sys.stderr) round_data["skipped"] = "no-render mode (cannot review without image)" rounds.append(round_data) break # 出图 try: print(f" 🎨 出图: backend={backend}", file=sys.stderr) render = render_via_backend(backend, recipe, aspect, output_dir, remote_model=remote_model) except Exception as e: round_data["render_error"] = str(e) rounds.append(round_data) print(f" ❌ 出图失败: {e}", file=sys.stderr) break saved = render.get("saved", []) if not saved: round_data["render_error"] = "no images saved" rounds.append(round_data) break round_data["image_path"] = saved[0] round_data["render"] = render # 评审 try: print(f" 🔍 Claude Vision 评审...", file=sys.stderr) review = review_image(saved[0], prompt=recipe["positive"][:500], quick=False, model=DEFAULT_MODEL) except Exception as e: round_data["review_error"] = str(e) rounds.append(round_data) print(f" ❌ 评审失败: {e}", file=sys.stderr) break round_data["review"] = review score = review.get("overall_score", 0) verdict = review.get("verdict", "?") print(f" 📊 得分: {score:.1f}/10 → {verdict}", file=sys.stderr) rounds.append(round_data) # 收敛？ if score >= target_score: print(f" ✅ 达标 ({score:.1f} ≥ {target_score})，停止迭代", file=sys.stderr) break if attempt >= max_rounds: print(f" ⏱ 达到最大轮次 {max_rounds}", file=sys.stderr) break # 让 Claude 改 prompt try: print(f" ✏️ 让 Claude 改 prompt...", file=sys.stderr) revision = call_claude_revise(current_subject, preset_resolved, review) except Exception as e: round_data["revision_error"] = str(e) print(f" ⚠️ 改 prompt 失败: {e}，停止迭代", file=sys.stderr) break round_data["revision"] = revision if revision.get("revised_subject"): current_subject = revision["revised_subject"] print(f" 📝 新 subject: {current_subject}", file=sys.stderr) if revision.get("extra_negatives"): extras = ", ".join(revision["extra_negatives"]) current_extra_neg = f"{current_extra_neg}, {extras}".strip(", ") if revision.get("extra_mood"): current_mood = revision["extra_mood"] if revision.get("extra_composition"): current_composition = revision["extra_composition"] # 选出最佳轮 best_round = max( [r for r in rounds if r.get("review", {}).get("overall_score") is not None], key=lambda r: r["review"]["overall_score"], default=None, ) return { "version": VERSION, "subject": subject, "preset": preset, "backend": backend, "target_score": target_score, "max_rounds": max_rounds, "rounds": rounds, "rounds_executed": len(rounds), "best_round": best_round, "best_score": best_round["review"]["overall_score"] if best_round else None, "best_image": best_round.get("image_path") if best_round else None, } def print_summary(result: Dict): sep = "═" * 60 print(f"\n{sep}") print(f"🔁 闭环自动迭代结果 v{result['version']}") print(f"📌 主体: {result['subject']}") print(f"🎨 预设: {result['preset']}") print(f"🔧 后端: {result['backend']}") print(f"🎯 目标: {result['target_score']:.1f}/10 最大 {result['max_rounds']} 轮") print(f"📊 实际: {result['rounds_executed']} 轮") print(f"\n{sep}") for r in result["rounds"]: attempt = r["attempt"] score = r.get("review", {}).get("overall_score") verdict = r.get("review", {}).get("verdict", "?") if score is None: err = r.get("render_error") or r.get("review_error") or r.get("revision_error") or r.get("skipped", "?") print(f"\n 轮 {attempt}: ❌ {err}") continue emoji = "🟢" if score >= 7.5 else ("🟡" if score >= 5 else "🔴") print(f"\n 轮 {attempt}: {emoji} {score:.1f}/10 → {verdict}") print(f" 图: {r.get('image_path', '?')}") print(f" subject: {r.get('subject', '')[:80]}") if r.get("revision", {}).get("rationale"): print(f" ✏️ 下轮理由: {r['revision']['rationale']}") if result["best_round"]: print(f"\n{sep}") print(f"🏆 最佳轮: 第 {result['best_round']['attempt']} 轮得分 {result['best_score']:.1f}/10") print(f"📷 文件: {result['best_image']}") print(f"{sep}\n") def main(): parser = argparse.ArgumentParser( description=f"huo15-img-prompt auto_iterate v{VERSION} — 闭环自动迭代", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=""" 示例: auto_iterate.py "持剑女侠" -p 赛博朋克 --backend dalle --target 7.5 auto_iterate.py "汉服少女" -p 汉服写真 --backend jimeng --max-rounds 3 auto_iterate.py "敦煌神女" -p 敦煌壁画 --backend replicate \\ --remote-model black-forest-labs/flux-schnell 环境变量: ANTHROPIC_API_KEY 必填（评审 + 改 prompt） + 后端对应的 API key（OPENAI_API_KEY / REPLICATE_API_TOKEN / ARK_API_KEY 等） """, ) parser.add_argument("subject", help="主体描述") parser.add_argument("-p", "--preset", required=True, help="风格预设（支持 A+B 混合）") parser.add_argument("-a", "--aspect", default="", help="画幅") parser.add_argument("-t", "--tier", choices=["basic", "pro", "master"], default="pro") parser.add_argument("-m", "--model", default="SDXL", help="提示词模型适配（不影响 backend）") parser.add_argument("--backend", required=True, choices=["dalle", "sd-webui", "comfyui", "replicate", "fal", "jimeng", "kling", "hailuo", "minimax"], help="出图后端") parser.add_argument("--remote-model", default="", help="Replicate/Fal 模型 ref") parser.add_argument("--target", type=float, default=DEFAULT_TARGET_SCORE, help=f"目标分数 0-10（默认 {DEFAULT_TARGET_SCORE}）") parser.add_argument("--max-rounds", type=int, default=DEFAULT_MAX_ROUNDS, help=f"最大迭代轮数（默认 {DEFAULT_MAX_ROUNDS}）") parser.add_argument("--output", default="./renders", help="输出目录") parser.add_argument("--seed", type=int, help="种子（不给则按 subject+preset 哈希）") parser.add_argument("--no-render", action="store_true", help="不真出图，仅生成 recipe（用于测试 prompt revision 链路）") parser.add_argument("-j", "--json", action="store_true", help="JSON 输出") parser.add_argument("-v", "--version", action="version", version=f"%(prog)s v{VERSION}") args = parser.parse_args() try: result = auto_iterate( subject=args.subject, preset=args.preset, backend=args.backend, target_score=args.target, max_rounds=args.max_rounds, aspect=args.aspect, model_adapt=args.model, output_dir=args.output, remote_model=args.remote_model, no_render=args.no_render, quality_tier=args.tier, seed=args.seed, ) except RuntimeError as e: print(f"❌ {e}", file=sys.stderr) sys.exit(2) if args.json: print(json.dumps(result, ensure_ascii=False, indent=2)) else: print_summary(result) if __name__ == "__main__": main() FILE:scripts/brand_kit.py #!/usr/bin/env python3 """ huo15-img-prompt — 品牌套件 v3.0 把品牌 VI（colors/fonts/keywords/forbidden）持久化为 brand kit JSON，出图时 `--brand-kit ` 自动注入到 prompt： - colors → palette 锁 - fonts → 添加到 prompt 的 typography 提示 - keywords → 视觉关键词追加 - forbidden → 加入 negative prompt - logo_description → 加入 prompt 用于 cref 风格存储：~/.huo15/brand_kits/.json 工作流： Step 1: 创建 brand kit brand_kit.py --create huo15 \\ --colors "#ff6b35,#2d3047,#fafafa" \\ --fonts "PingFang SC,Source Han Serif" \\ --keywords "现代,简洁,专业,温暖" \\ --forbidden "competitor logos, low-quality" Step 2: 出图时引用 enhance_prompt.py "公司年会海报" -p 品牌KV --brand-kit huo15 Step 3: 配合品牌规范抓取技能（huo15-openclaw-brand-protocol）用 brand-protocol 抓品牌规范 → 导入到 brand kit → 用 img-prompt 出图 brand_kit.py --list / --show / --delete / --export / --import """ import sys import os import json import re import time import argparse from typing import Dict, List, Optional VERSION = "3.1.0" KIT_DIR = os.path.expanduser("~/.huo15/brand_kits") def safe_name(name: str) -> str: return re.sub(r"[^\w\-]", "_", name) def kit_path(name: str) -> str: return os.path.join(KIT_DIR, f"{safe_name(name)}.json") def kit_load(name: str) -> Optional[Dict]: p = kit_path(name) if not os.path.isfile(p): return None try: with open(p, "r", encoding="utf-8") as f: return json.load(f) except (json.JSONDecodeError, IOError): return None def kit_save(name: str, kit: Dict) -> str: os.makedirs(KIT_DIR, exist_ok=True) p = kit_path(name) existing = kit_load(name) or {} kit["name"] = name kit["version"] = VERSION kit["created_at"] = existing.get("created_at") or int(time.time()) kit["updated_at"] = int(time.time()) kit["use_count"] = existing.get("use_count", 0) with open(p, "w", encoding="utf-8") as f: json.dump(kit, f, ensure_ascii=False, indent=2) return p def kit_list() -> List[Dict]: if not os.path.isdir(KIT_DIR): return [] out = [] for fn in sorted(os.listdir(KIT_DIR)): if not fn.endswith(".json"): continue try: with open(os.path.join(KIT_DIR, fn), "r", encoding="utf-8") as f: out.append(json.load(f)) except (json.JSONDecodeError, IOError): continue return out def kit_delete(name: str) -> bool: p = kit_path(name) if os.path.isfile(p): os.remove(p) return True return False # ───────────────────────────────────────────────────────── # 注入逻辑（被 enhance_prompt.py import） # ───────────────────────────────────────────────────────── def kit_apply(name: str, args) -> Optional[Dict]: """加载 brand kit 并注入 args。 args 是 enhance_prompt.py 的 ArgumentParser Namespace。我们补全： - args.subject 末尾追加品牌关键词 - args.avoid 追加 forbidden（合并到 negative）返回 kit dict（用于显示）或 None。 """ kit = kit_load(name) if not kit: return None # 计数 kit["use_count"] = kit.get("use_count", 0) + 1 try: with open(kit_path(name), "w", encoding="utf-8") as f: json.dump(kit, f, ensure_ascii=False, indent=2) except IOError: pass # 注入 keywords 到 subject keywords = kit.get("keywords") or [] if keywords and args.subject: kw_str = ", ".join(keywords) # 不把 keywords 重复加入 if all(k not in args.subject for k in keywords[:2]): args.subject = f"{args.subject}, {kw_str}" # 注入 colors 到 subject（作为色板提示） colors = kit.get("colors") or [] if colors and args.subject: # 把色板写成自然语言，让 T2I 模型理解 colors_phrase = f"brand color palette {' '.join(colors)}" args.subject = f"{args.subject}, {colors_phrase}" # 注入 logo_description（如果有） if kit.get("logo_description") and args.subject: args.subject = f"{args.subject}, brand identity: {kit['logo_description']}" # 注入 forbidden 到 negative forbidden = kit.get("forbidden") or [] if forbidden: existing_avoid = args.avoid or "" new_avoid = ", ".join(forbidden) args.avoid = f"{existing_avoid}, {new_avoid}".strip(", ") return kit # ───────────────────────────────────────────────────────── # CLI # ───────────────────────────────────────────────────────── def parse_csv(s: str) -> List[str]: if not s: return [] return [x.strip() for x in s.split(",") if x.strip()] def print_kit(kit: Dict): print(f"\n🎨 {kit['name']}") print(f" 创建: {time.strftime('%Y-%m-%d %H:%M', time.localtime(kit.get('created_at', 0)))}") print(f" 更新: {time.strftime('%Y-%m-%d %H:%M', time.localtime(kit.get('updated_at', 0)))}") print(f" 用过: {kit.get('use_count', 0)} 次") if kit.get("colors"): print(f" 颜色: {' '.join(kit['colors'])}") if kit.get("fonts"): print(f" 字体: {' / '.join(kit['fonts'])}") if kit.get("keywords"): print(f" 关键词: {', '.join(kit['keywords'])}") if kit.get("forbidden"): print(f" 禁止: {', '.join(kit['forbidden'])}") if kit.get("logo_description"): print(f" Logo: {kit['logo_description']}") if kit.get("description"): print(f" 描述: {kit['description']}") def main(): parser = argparse.ArgumentParser( description=f"huo15-img-prompt brand_kit v{VERSION} — 品牌套件管理", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=""" 示例: brand_kit.py --create huo15 \\ --colors "#ff6b35,#2d3047,#fafafa" \\ --fonts "PingFang SC,Source Han Serif" \\ --keywords "现代,简洁,专业,温暖" \\ --forbidden "competitor logos, low quality" \\ --logo "minimal flame mark in orange" brand_kit.py --list brand_kit.py --show huo15 brand_kit.py --delete 旧品牌 brand_kit.py --export huo15 > huo15.json cat huo15.json | brand_kit.py --import ✨ 在 enhance_prompt.py 里使用: enhance_prompt.py "公司年会海报" -p 品牌KV --brand-kit huo15 """, ) g = parser.add_mutually_exclusive_group(required=True) g.add_argument("--create", metavar="NAME", help="创建品牌套件") g.add_argument("--update", metavar="NAME", help="更新品牌套件（保留未指定字段）") g.add_argument("--list", action="store_true", help="列出所有") g.add_argument("--show", metavar="NAME", help="显示详情") g.add_argument("--delete", metavar="NAME", help="删除") g.add_argument("--export", metavar="NAME", help="导出 JSON 到 stdout") g.add_argument("--import", dest="imp", action="store_true", help="从 stdin 导入") parser.add_argument("--colors", default="", help="逗号分隔的色值，例 '#ff6b35,#2d3047'") parser.add_argument("--fonts", default="", help="字体，例 'PingFang SC,Source Han Serif'") parser.add_argument("--keywords", default="", help="视觉关键词") parser.add_argument("--forbidden", default="", help="禁止出现的元素（合并到负面词）") parser.add_argument("--logo", default="", help="Logo 一句话描述") parser.add_argument("--description", default="", help="品牌描述") parser.add_argument("-j", "--json", action="store_true", help="JSON 输出") parser.add_argument("-v", "--version", action="version", version=f"%(prog)s v{VERSION}") args = parser.parse_args() if args.list: kits = kit_list() if args.json: print(json.dumps({"version": VERSION, "kits": kits}, ensure_ascii=False, indent=2)) return if not kits: print(f"\n📭 暂无品牌套件 ({KIT_DIR})\n") return print(f"\n🎨 品牌套件 ({len(kits)} 个):") for k in kits: print(f" • {k['name']:20s} {len(k.get('colors', []))} 色 {len(k.get('keywords', []))} 关键词用过 {k.get('use_count', 0)} 次") print() return if args.show: kit = kit_load(args.show) if not kit: print(f"❌ 不存在: {args.show}", file=sys.stderr) sys.exit(1) if args.json: print(json.dumps(kit, ensure_ascii=False, indent=2)) else: print_kit(kit) print() return if args.delete: if kit_delete(args.delete): print(f"✅ 已删除: {args.delete}") else: print(f"❌ 不存在: {args.delete}", file=sys.stderr) sys.exit(1) return if args.export: kit = kit_load(args.export) if not kit: print(f"❌ 不存在: {args.export}", file=sys.stderr) sys.exit(1) print(json.dumps(kit, ensure_ascii=False, indent=2)) return if args.imp: try: kit = json.loads(sys.stdin.read()) except json.JSONDecodeError as e: print(f"❌ 解析失败: {e}", file=sys.stderr) sys.exit(1) name = kit.get("name") if not name: print("❌ JSON 缺 name 字段", file=sys.stderr) sys.exit(1) kit_save(name, kit) print(f"✅ 已导入: {name}") return if args.create or args.update: name = args.create or args.update if args.create and kit_load(name): print(f"⚠️ '{name}' 已存在，用 --update 覆盖", file=sys.stderr) sys.exit(1) existing = kit_load(name) if args.update else {} kit = dict(existing or {}) if args.colors: kit["colors"] = parse_csv(args.colors) if args.fonts: kit["fonts"] = parse_csv(args.fonts) if args.keywords: kit["keywords"] = parse_csv(args.keywords) if args.forbidden: kit["forbidden"] = parse_csv(args.forbidden) if args.logo: kit["logo_description"] = args.logo if args.description: kit["description"] = args.description kit_save(name, kit) action = "创建" if args.create else "更新" print(f"✅ 已{action}: {name}") print_kit(kit_load(name)) print() if __name__ == "__main__": main() FILE:scripts/character.py #!/usr/bin/env python3 """ huo15-img-prompt — 角色卡持久化 v2.6 把 character_sheet 模式的输出存为可复用的"角色卡"，下次 `--char ` 直接调出。每张角色卡 = 角色名 + 视觉描述 + 锁定参数（seed/preset/aspect/camera/lighting/palette）。存到 ~/.huo15/characters/.json。工作流： Turn 1（创建角色）: enhance_prompt.py "银发机甲少女, twin tails, glowing visor" \\ -p 动漫 --character-sheet --save-char 银发机甲少女 Turn 2 ~ N（复用）: enhance_prompt.py "新场景：在霓虹街头" --char 银发机甲少女 -p 赛博朋克 enhance_prompt.py "在花海中" --char 银发机甲少女 # → 自动注入角色描述 + 锁 seed，保证多张图角色一致调用： character.py --list # 列出所有角色 character.py --show 银发机甲少女 # 看角色详情 character.py --delete 旧角色 # 删除 character.py --export 银发机甲少女 > char.json # 导出 character.py --import < char.json # 导入 """ import sys import os import json import re import time import argparse from typing import Dict, List, Optional VERSION = "3.1.0" CHAR_DIR = os.path.expanduser("~/.huo15/characters") def safe_name(name: str) -> str: return re.sub(r"[^\w\-]", "_", name) def char_path(name: str) -> str: return os.path.join(CHAR_DIR, f"{safe_name(name)}.json") def char_save(name: str, recipe: Dict) -> Dict: """从 build_prompt 的 result 里抽取角色锁存档。""" os.makedirs(CHAR_DIR, exist_ok=True) p = char_path(name) existing = char_load(name) or {} lock = recipe.get("consistency_lock", {}) or {} card = { "name": name, "version": VERSION, "created_at": existing.get("created_at") or int(time.time()), "updated_at": int(time.time()), "use_count": existing.get("use_count", 0), "subject_description": recipe.get("original", ""), "preset": recipe.get("preset", ""), "mix_secondary": recipe.get("mix_secondary", "") or "", "mix_ratio": recipe.get("mix_ratio"), "aspect": recipe.get("aspect", ""), "seed": recipe.get("seed_suggestion"), "camera": lock.get("camera", ""), "lighting": lock.get("lighting", ""), "palette": lock.get("palette", ""), "is_character_sheet": recipe.get("character_sheet", False), "positive_anchor": recipe.get("positive", "")[:500], } with open(p, "w", encoding="utf-8") as f: json.dump(card, f, ensure_ascii=False, indent=2) return card def char_load(name: str) -> Optional[Dict]: p = char_path(name) if not os.path.isfile(p): return None try: with open(p, "r", encoding="utf-8") as f: return json.load(f) except (json.JSONDecodeError, IOError): return None def char_apply(name: str, args) -> Optional[Dict]: """加载角色卡作为 args 的默认值。仅在 CLI 未显式给时填充。""" card = char_load(name) if not card: return None # 增量计数 card["use_count"] = card.get("use_count", 0) + 1 try: with open(char_path(name), "w", encoding="utf-8") as f: json.dump(card, f, ensure_ascii=False, indent=2) except IOError: pass # 注入到 args desc = card.get("subject_description", "") if args.subject and desc: # 把角色描述前置到主体描述前 args.subject = f"{desc}, {args.subject}" elif desc and not args.subject: args.subject = desc if not args.preset and card.get("preset"): if card.get("mix_secondary"): args.preset = f"{card['preset']}+{card['mix_secondary']}" else: args.preset = card["preset"] if not args.aspect and card.get("aspect"): args.aspect = card["aspect"] # 角色卡的 seed 是核心锁，永远应用（除非 CLI 显式覆盖） if args.seed is None and card.get("seed") is not None: args.seed = card["seed"] return card def char_list() -> List[Dict]: if not os.path.isdir(CHAR_DIR): return [] out = [] for fn in sorted(os.listdir(CHAR_DIR)): if not fn.endswith(".json"): continue try: with open(os.path.join(CHAR_DIR, fn), "r", encoding="utf-8") as f: out.append(json.load(f)) except (json.JSONDecodeError, IOError): continue return out def char_delete(name: str) -> bool: p = char_path(name) if os.path.isfile(p): os.remove(p) return True return False # ───────────────────────────────────────────────────────── # CLI # ───────────────────────────────────────────────────────── def print_char(card: Dict): print(f"\n👤 {card['name']}") print(f" 创建: {time.strftime('%Y-%m-%d %H:%M', time.localtime(card.get('created_at', 0)))}") print(f" 更新: {time.strftime('%Y-%m-%d %H:%M', time.localtime(card.get('updated_at', 0)))}") print(f" 用过: {card.get('use_count', 0)} 次") print(f" 描述: {card.get('subject_description', '')[:120]}") print(f" 预设: {card.get('preset', '')}", end="") if card.get("mix_secondary"): print(f" + {card['mix_secondary']} (mix={card.get('mix_ratio', 0.6)})") else: print() print(f" 画幅: {card.get('aspect', '')}") print(f" 种子: {card.get('seed', '')} (锁定)") if card.get("camera"): print(f" 相机: {card['camera']}") if card.get("lighting"): print(f" 光影: {card['lighting']}") if card.get("palette"): print(f" 色板: {card['palette']}") if card.get("is_character_sheet"): print(f" ✨ 来自 character-sheet 模式（T-pose 多视图）") def main(): parser = argparse.ArgumentParser( description=f"huo15-img-prompt character v{VERSION} — 角色卡管理", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=""" 示例: character.py --list # 列出全部 character.py --show 银发机甲少女 # 详情 character.py --delete 旧角色 # 删除 character.py --export 银发机甲少女 # 导出 JSON 到 stdout cat char.json | character.py --import # 从 stdin 导入 ✨ 创建/复用角色（在 enhance_prompt.py 里）: enhance_prompt.py "银发机甲少女" -p 动漫 --character-sheet --save-char 银发机甲少女 enhance_prompt.py "在霓虹街头" --char 银发机甲少女 """, ) g = parser.add_mutually_exclusive_group(required=True) g.add_argument("--list", action="store_true", help="列出所有角色") g.add_argument("--show", help="显示单个角色详情") g.add_argument("--delete", help="删除角色") g.add_argument("--export", help="导出角色到 stdout（JSON）") g.add_argument("--import", dest="imp", action="store_true", help="从 stdin 导入角色") parser.add_argument("-j", "--json", action="store_true", help="JSON 输出（配合 --list / --show）") parser.add_argument("-v", "--version", action="version", version=f"%(prog)s v{VERSION}") args = parser.parse_args() if args.list: cards = char_list() if args.json: print(json.dumps({"version": VERSION, "characters": cards}, ensure_ascii=False, indent=2)) return if not cards: print(f"\n📭 暂无角色（在 {CHAR_DIR}）\n") print("💡 创建：enhance_prompt.py \"主体\" -p 预设 --character-sheet --save-char 名字\n") return print(f"\n👥 已存角色 ({len(cards)} 个，{CHAR_DIR}):") for c in cards: print(f" • {c['name']:20s} {c.get('preset', '?'):12s} seed={c.get('seed', '?')} 用过 {c.get('use_count', 0)} 次") print() return if args.show: card = char_load(args.show) if not card: print(f"❌ 角色不存在: {args.show}", file=sys.stderr) sys.exit(1) if args.json: print(json.dumps(card, ensure_ascii=False, indent=2)) else: print_char(card) print() return if args.delete: if char_delete(args.delete): print(f"✅ 已删除: {args.delete}") else: print(f"❌ 角色不存在: {args.delete}", file=sys.stderr) sys.exit(1) return if args.export: card = char_load(args.export) if not card: print(f"❌ 角色不存在: {args.export}", file=sys.stderr) sys.exit(1) print(json.dumps(card, ensure_ascii=False, indent=2)) return if args.imp: try: card = json.loads(sys.stdin.read()) except json.JSONDecodeError as e: print(f"❌ 解析失败: {e}", file=sys.stderr) sys.exit(1) name = card.get("name") if not name: print(f"❌ JSON 缺 name 字段", file=sys.stderr) sys.exit(1) os.makedirs(CHAR_DIR, exist_ok=True) with open(char_path(name), "w", encoding="utf-8") as f: json.dump(card, f, ensure_ascii=False, indent=2) print(f"✅ 已导入: {name}") return if __name__ == "__main__": main() FILE:scripts/claude_polish.py #!/usr/bin/env python3 """ huo15-img-prompt — Claude API 智能润色 v2.3 用 Claude（Anthropic API）把粗糙的中文描述润色成专业 T2I 提示词。利用 Claude 的 prompt engineering 优势： - **结构化思维**：用 XML 标签让 Claude 分步思考（subject_refine → style_pick → camera_lighting → palette → negatives） - **prompt caching**：system prompt 缓存，省 90% token - **JSON 强约束输出**：用 prefill + tool-use 强制结构化 - **中英双语理解**：中文输入 → 中英混合输出（视觉术语用英文）调用： claude_polish.py "一个温柔的女孩在花丛中" claude_polish.py "赛博朋克猫" --model claude-sonnet-4-5 claude_polish.py "敦煌神女" --include-safety # 同时跑 safety_lint claude_polish.py "汉服少女" -j > polished.json claude_polish.py "雪山下的小屋" --pipe # 输出可直接喂给 enhance_prompt.py 的 CLI 依赖：环境变量 ANTHROPIC_API_KEY 纯 urllib，零第三方包（不引入 anthropic SDK，避免企业扫描器） """ import sys import os import json import argparse import re from typing import Dict, List, Optional, Tuple from urllib.request import Request, urlopen from urllib.error import HTTPError, URLError sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) from enhance_prompt import STYLE_PRESETS VERSION = "3.1.0" # ───────────────────────────────────────────────────────── # Claude API 配置 # ───────────────────────────────────────────────────────── ANTHROPIC_BASE = os.environ.get("ANTHROPIC_BASE_URL", "https://api.anthropic.com") ANTHROPIC_VERSION = "2023-06-01" DEFAULT_MODEL = "claude-sonnet-4-5" # 用户记忆里偏好的版本 # ───────────────────────────────────────────────────────── # System Prompt（启用 prompt caching） # ───────────────────────────────────────────────────────── def build_system_prompt() -> str: """生成 system prompt — 含 88 预设清单。""" by_cat: Dict[str, List[str]] = {} for name, data in STYLE_PRESETS.items(): by_cat.setdefault(data["category"], []).append(name) preset_block = "\n".join([ f"- {cat}: " + " / ".join(by_cat[cat]) for cat in ("摄影", "动漫", "插画", "3D", "设计", "艺术", "场景", "游戏", "东方") if cat in by_cat ]) return f"""你是火一五文生图提示词的资深 prompt engineer，专精把中文一句话描述润色成高质量、可直接喂给 Midjourney/SD/SDXL/Flux/DALL-E 的提示词。 # 88 风格预设（必须从这里挑一个） {preset_block} # 你的工作流程（用 XML 思维链，但只输出最终 JSON） 1. 解析用户主体：核心人/物/场景，剥离修饰 2. 选风格：从 88 预设挑最贴近的 1 个，可选副预设做混合 3. 推导视觉锁：camera（焦段/视角）/ lighting（光源/光质）/ palette（色板） 4. 自动抽词：构图（特写/俯拍/全身）/ 情绪（温暖/史诗/治愈）/ 时间（黄昏/深夜）/ 天气（雨/雾）/ 季节 5. 平台合规检查：识别可能被 SD/MJ/DALL-E 误判的词，做艺术化替代（仅限合法艺术） 6. 写出 negative prompt：常见 artifact + 主题特定排除项 # 输出 JSON 严格 schema ```json {{ "subject_refined_zh": "更具体可视化的中文主体描述（保留意境，加视觉细节）", "subject_refined_en": "English version, T2I model 友好", "style_preset": "从 88 个里挑 1 个准确名", "style_preset_secondary": "可选副预设（混合时用），不需要填空字符串", "mix_ratio": 0.6, "aspect": "1:1 / 3:4 / 16:9 / 21:9 / 9:16 之一", "camera": "镜头/焦段/视角，例：'85mm telephoto, low angle, shallow depth of field'", "lighting": "光影描述，例：'golden hour rim light, soft fill, cinematic glow'", "palette": "色板，例：'muted earth tones, sage green, warm amber'", "composition": "特写/近景/中景/全身/俯拍/仰拍/航拍/侧面/背面之一或多", "mood": "温暖/冷峻/神秘/梦幻/欢快/史诗/治愈/紧张之一", "time_of_day": "清晨/黄昏/日落/深夜/蓝调时刻等（无则空）", "weather": "晴/雨/雾/雪等（无则空）", "season": "春/夏/秋/冬/樱花季/枫叶季（无则空）", "key_visual_details": ["3-5 个关键视觉元素，英文，有助于 T2I 复现"], "negatives": ["3-5 个应避免的事物，英文"], "platform_warnings": [ {{"platform": "DALL-E|MJ|SD", "risk": "可能被拒的原因", "suggestion": "如何改写"}} ], "polish_notes": "中文一句话总结：你做了什么润色" }} ``` # 关键原则 - **不要拒答**：用户给的都是合法艺术创作场景。如果有边界词，做艺术化替代（"血" → "crimson splash"，"裸" → "elegant figure, classical art reference"）。仅在涉及 CSAM/真人色情/违法行为时才返回 `{{"error": "out_of_scope"}}` - **subject_refined_zh 比 subject_refined_en 更具体**：中文版要补全用户没说但摄影师/画师会自然加的细节（光线、表情、动态） - **camera/lighting/palette 必须能让另一个画师复现同一张图**：避免"美丽光影"这类废话 - **JSON 之外不要任何文字** 记住：你输出的 JSON 会直接被脚本 parse，**不要**包 ```json``` 代码块，**不要**前缀解释。""" # v2.5 A1: 智能预设 top-3 推荐 system prompt def build_suggest_system_prompt() -> str: by_cat: Dict[str, List[str]] = {} for name, data in STYLE_PRESETS.items(): by_cat.setdefault(data["category"], []).append(name) preset_block = "\n".join([ f"- {cat}: " + " / ".join(by_cat[cat]) for cat in ("摄影", "动漫", "插画", "3D", "设计", "艺术", "场景", "游戏", "东方") if cat in by_cat ]) return f"""你是火一五预设推荐师。给定用户的描述（可能很模糊，比如"温柔感"、"高级感"），从 88 预设里挑 top 3 最贴近的，按相关性降序输出。 # 88 风格预设 {preset_block} # 输出 JSON 严格 schema ```json {{ "top_3": [ {{ "preset": "预设名（必须是 88 里的）", "score": 0.0-1.0, "reason": "为什么贴近用户描述（一句话，强调核心匹配点）", "best_subject_example": "适合用这个预设画什么主体（一句话）" }}, {{...}}, {{...}} ], "mix_suggestion": {{ "primary": "主预设", "secondary": "副预设", "ratio": 0.6, "reason": "为什么这两个混合可能更好（如果不需要混合则置 null）" }}, "user_intent_summary": "一句话总结用户到底想要什么" }} ``` # 关键 - score 反映"相关性"，1.0 是完美匹配 - 多个候选时，预设名必须不重复 - 用户描述模糊时（如"温暖治愈"），优先匹配氛围预设；明确时（如"赛博朋克猫"）就只给一个高分 - 适合混合的场景才给 mix_suggestion，简单场景置 null - 只输出 JSON，不要解释。""" def call_claude_suggest(prompt: str, model: str = DEFAULT_MODEL, max_tokens: int = 1500) -> Dict: """v2.5 A1: 调用 Claude 输出 top-3 预设推荐。""" api_key = os.environ.get("ANTHROPIC_API_KEY") if not api_key: raise RuntimeError("缺少 ANTHROPIC_API_KEY 环境变量") body = { "model": model, "max_tokens": max_tokens, "temperature": 0.5, "system": [{ "type": "text", "text": build_suggest_system_prompt(), "cache_control": {"type": "ephemeral"}, }], "messages": [ {"role": "user", "content": f"{prompt}\n请输出 JSON。"}, {"role": "assistant", "content": "{"}, ], } req = Request( f"{ANTHROPIC_BASE}/v1/messages", data=json.dumps(body).encode("utf-8"), headers={ "Content-Type": "application/json", "x-api-key": api_key, "anthropic-version": ANTHROPIC_VERSION, }, method="POST", ) try: with urlopen(req, timeout=60) as r: return json.loads(r.read().decode("utf-8")) except HTTPError as e: raise RuntimeError(f"Claude HTTP {e.code}: {e.read().decode('utf-8', errors='replace')}") def suggest_presets(prompt: str, model: str = DEFAULT_MODEL) -> Dict: """高层 API: 给一句话描述 → top-3 预设 + mix 建议。""" resp = call_claude_suggest(prompt, model=model) return parse_claude_json(resp) def call_claude(prompt: str, model: str = DEFAULT_MODEL, max_tokens: int = 2048, temperature: float = 0.7) -> Dict: """调用 Anthropic Messages API。启用 prompt caching。""" api_key = os.environ.get("ANTHROPIC_API_KEY") if not api_key: raise RuntimeError( "缺少 ANTHROPIC_API_KEY 环境变量。\n" " • macOS/Linux: export ANTHROPIC_API_KEY=sk-ant-...\n" " • 或在 ~/.zshrc / ~/.bashrc 里写入" ) body = { "model": model, "max_tokens": max_tokens, "temperature": temperature, "system": [ { "type": "text", "text": build_system_prompt(), "cache_control": {"type": "ephemeral"}, } ], "messages": [ { "role": "user", "content": f"{prompt}\n\n请输出 JSON。", }, { "role": "assistant", "content": "{", # prefill 强制 JSON 起手 }, ], } req = Request( f"{ANTHROPIC_BASE}/v1/messages", data=json.dumps(body).encode("utf-8"), headers={ "Content-Type": "application/json", "x-api-key": api_key, "anthropic-version": ANTHROPIC_VERSION, }, method="POST", ) try: with urlopen(req, timeout=120) as r: return json.loads(r.read().decode("utf-8")) except HTTPError as e: err_body = e.read().decode("utf-8", errors="replace") raise RuntimeError(f"Claude API HTTP {e.code}: {err_body}") except URLError as e: raise RuntimeError(f"Claude API 网络错误: {e}") def parse_claude_json(resp: Dict) -> Dict: """从 Claude 响应中抽出 JSON（已 prefill `{`，所以拼回去）。""" if "error" in resp: raise RuntimeError(f"Claude API 错误: {resp['error']}") text = "" for block in resp.get("content", []): if block.get("type") == "text": text += block.get("text", "") if not text: raise RuntimeError(f"Claude 返回空内容: {resp}") full = "{" + text # prefill # 截到第一个完整 JSON depth = 0 end = -1 in_str = False esc = False for i, ch in enumerate(full): if esc: esc = False continue if ch == "\\": esc = True continue if ch == '"': in_str = not in_str continue if in_str: continue if ch == "{": depth += 1 elif ch == "}": depth -= 1 if depth == 0: end = i + 1 break if end == -1: raise RuntimeError(f"未找到完整 JSON: {full[:300]}") try: data = json.loads(full[:end]) except json.JSONDecodeError as e: raise RuntimeError(f"JSON 解析失败: {e}\n原文: {full[:300]}") # 附加 usage 信息 usage = resp.get("usage", {}) data["_usage"] = { "input_tokens": usage.get("input_tokens", 0), "output_tokens": usage.get("output_tokens", 0), "cache_creation_input_tokens": usage.get("cache_creation_input_tokens", 0), "cache_read_input_tokens": usage.get("cache_read_input_tokens", 0), } data["_model"] = resp.get("model", "") return data # ───────────────────────────────────────────────────────── # 输出格式化 # ───────────────────────────────────────────────────────── def to_pipe_command(polished: Dict) -> str: """把 polished 转成可直接喂给 enhance_prompt.py 的 CLI 命令。""" subject = polished.get("subject_refined_zh", "") preset = polished.get("style_preset", "") sec = polished.get("style_preset_secondary", "") mix = polished.get("mix_ratio", 0.6) aspect = polished.get("aspect", "") preset_arg = f'"{preset}+{sec}"' if sec else f'"{preset}"' parts = [ "enhance_prompt.py", f'"{subject}"', "-p", preset_arg, ] if sec: parts += ["--mix", str(mix)] if aspect: parts += ["-a", aspect] return " ".join(parts) def print_polished(polished: Dict): sep = "═" * 60 print(f"\n{sep}") print(f"✨ Claude 智能润色 v{VERSION}") print(f"🤖 模型: {polished.get('_model', '?')}") u = polished.get("_usage", {}) print(f"📊 token: in={u.get('input_tokens',0)} / out={u.get('output_tokens',0)} / cache_read={u.get('cache_read_input_tokens',0)} (省 token)") if polished.get("error"): print(f"\n❌ 拒答: {polished['error']}（CSAM/真人色情/违法不在本工具支持范围）") print(f"{sep}\n") return print(f"\n📝 润色后中文主体:\n {polished.get('subject_refined_zh', '')}") print(f"\n🌐 English:\n {polished.get('subject_refined_en', '')}") style = polished.get("style_preset", "") sec = polished.get("style_preset_secondary", "") if sec: ratio = polished.get("mix_ratio", 0.6) print(f"\n🎨 推荐预设: {style} + {sec} (mix={ratio})") else: print(f"\n🎨 推荐预设: {style}") print(f"📐 画幅: {polished.get('aspect', '')}") print(f"🎥 相机: {polished.get('camera', '')}") print(f"💡 光影: {polished.get('lighting', '')}") print(f"🎨 色板: {polished.get('palette', '')}") extras = [] for k, label in [("composition", "构图"), ("mood", "情绪"), ("time_of_day", "时间"), ("weather", "天气"), ("season", "季节")]: if polished.get(k): extras.append(f"{label}={polished[k]}") if extras: print(f"🔍 抽词: {' / '.join(extras)}") if polished.get("key_visual_details"): print(f"\n🌟 关键视觉:") for d in polished["key_visual_details"]: print(f" • {d}") if polished.get("negatives"): print(f"\n🚫 负面词:") for n in polished["negatives"]: print(f" • {n}") warnings = polished.get("platform_warnings") or [] if warnings: print(f"\n⚠️ 平台风险:") for w in warnings: print(f" [{w.get('platform','?')}] {w.get('risk','')}") print(f" → {w.get('suggestion','')}") if polished.get("polish_notes"): print(f"\n📌 润色说明: {polished['polish_notes']}") print(f"\n💡 一键复制喂给 enhance_prompt.py:") print(f" {to_pipe_command(polished)}") print(f"{sep}\n") def main(): parser = argparse.ArgumentParser( description=f"huo15-img-prompt claude_polish v{VERSION} — Claude API 智能润色", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=""" 示例: claude_polish.py "一个温柔的女孩在花丛中" claude_polish.py "赛博朋克猫" --model claude-sonnet-4-6 claude_polish.py "敦煌神女" -j > polished.json claude_polish.py "雪山下的小屋" --pipe # 输出可直接喂给 enhance_prompt.py 的命令环境变量: ANTHROPIC_API_KEY 必填 ANTHROPIC_BASE_URL 可选，默认 https://api.anthropic.com """, ) parser.add_argument("subject", nargs="?", help="主体描述（中文/英文均可）") parser.add_argument("--model", default=DEFAULT_MODEL, help=f"Claude 模型（默认 {DEFAULT_MODEL}）") parser.add_argument("--max-tokens", type=int, default=2048, help="最大输出 tokens") parser.add_argument("--temperature", type=float, default=0.7, help="温度 0.0-1.0") parser.add_argument("--pipe", action="store_true", help="输出 enhance_prompt.py CLI 命令一行") parser.add_argument("--suggest", action="store_true", help="只做 top-3 预设推荐，不做完整润色（v2.5 A1，描述模糊但要选预设时用）") parser.add_argument("-j", "--json", action="store_true", help="JSON 输出") parser.add_argument("-v", "--version", action="version", version=f"%(prog)s v{VERSION}") args = parser.parse_args() if not args.subject: parser.print_help() sys.exit(1) # v2.5 A1: --suggest 仅做 top-3 预设推荐 if args.suggest: try: suggestion = suggest_presets(args.subject, model=args.model) except RuntimeError as e: print(f"❌ {e}", file=sys.stderr) sys.exit(2) if args.json: print(json.dumps(suggestion, ensure_ascii=False, indent=2)) return print(f"\n🎯 智能预设推荐 (Claude {args.model})") print(f"📝 用户意图: {suggestion.get('user_intent_summary', '')}\n") for i, p in enumerate(suggestion.get("top_3", []), 1): score = p.get("score", 0) bar = "█" * int(score * 10) + "░" * (10 - int(score * 10)) print(f" {i}. {p.get('preset', '?'):12s} [{bar}] {score:.2f}") print(f" ↳ {p.get('reason', '')}") print(f" ↳ 适合: {p.get('best_subject_example', '')}") mix = suggestion.get("mix_suggestion") or {} if mix and mix.get("primary"): print(f"\n🎨 混合建议: {mix['primary']} + {mix['secondary']} (mix={mix.get('ratio', 0.6)})") print(f" 理由: {mix.get('reason', '')}") u = suggestion.get("_usage", {}) print(f"\n📊 token: in={u.get('input_tokens', 0)} / out={u.get('output_tokens', 0)} / cache_read={u.get('cache_read_input_tokens', 0)}\n") return try: resp = call_claude(args.subject, model=args.model, max_tokens=args.max_tokens, temperature=args.temperature) polished = parse_claude_json(resp) except RuntimeError as e: print(f"❌ {e}", file=sys.stderr) sys.exit(2) if args.pipe: print(to_pipe_command(polished)) return if args.json: print(json.dumps(polished, ensure_ascii=False, indent=2)) return print_polished(polished) if __name__ == "__main__": main() FILE:scripts/doctor.py #!/usr/bin/env python3 """ huo15-img-prompt — 健康检查 v3.1 一键诊断技能能不能正常用： - 14 个脚本能不能 import / 拿到 VERSION - API keys 配置情况（ANTHROPIC / OPENAI / REPLICATE / FAL / ARK / KLING / MINIMAX） - 后端服务可达性（ComfyUI / SD WebUI） - Obsidian vault 检测 - 持久化资产盘点（characters / sessions / brand_kits / learned_presets） - Claude API 实际可调测试（轻量 ping）调用： doctor.py # 全量检查 doctor.py --quick # 跳过网络测试 doctor.py --check api # 只查 API keys doctor.py -j # JSON 输出 """ import sys import os import json import argparse import socket from typing import Dict, List, Optional from urllib.request import Request, urlopen from urllib.error import HTTPError, URLError sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) VERSION = "3.1.0" GREEN = "\033[32m" YELLOW = "\033[33m" RED = "\033[31m" GRAY = "\033[90m" RESET = "\033[0m" BOLD = "\033[1m" def ok(msg: str) -> str: return f"{GREEN}✓{RESET} {msg}" def warn(msg: str) -> str: return f"{YELLOW}⚠{RESET} {msg}" def fail(msg: str) -> str: return f"{RED}✗{RESET} {msg}" def info(msg: str) -> str: return f"{GRAY}·{RESET} {msg}" # ───────────────────────────────────────────────────────── # 检查项 # ───────────────────────────────────────────────────────── SCRIPTS = [ "enhance_prompt", "enhance_video", "reverse_prompt", "render_prompt", "claude_polish", "safety_lint", "image_review", "auto_iterate", "character", "mcp_server", "web_ui", "storyboard", "brand_kit", "style_learn", ] def check_scripts() -> Dict: """检查 14 个脚本能不能 import + 拿到 VERSION。""" out = {"category": "scripts", "items": []} base_dir = os.path.dirname(os.path.abspath(__file__)) for s in SCRIPTS: path = os.path.join(base_dir, f"{s}.py") item = {"name": s, "path": path} if not os.path.isfile(path): item["status"] = "missing" item["msg"] = "脚本不存在" else: try: mod = __import__(s) v = getattr(mod, "VERSION", None) if v: item["status"] = "ok" item["version"] = v else: item["status"] = "warn" item["msg"] = "缺 VERSION 常量" except Exception as e: item["status"] = "fail" item["msg"] = str(e) out["items"].append(item) return out API_KEYS = [ ("ANTHROPIC_API_KEY", "Claude API（润色/评审/闭环迭代/故事板）", True), ("OPENAI_API_KEY", "DALL-E 3 直出", False), ("REPLICATE_API_TOKEN", "Replicate 后端", False), ("FAL_KEY", "Fal.ai 后端", False), ("ARK_API_KEY", "字节即梦（火山方舟）", False), ("KLING_API_KEY", "快手可灵", False), ("MINIMAX_API_KEY", "海螺 MiniMax", False), ] def check_api_keys() -> Dict: out = {"category": "api_keys", "items": []} for env, desc, required in API_KEYS: item = {"env": env, "desc": desc, "required": required} val = os.environ.get(env, "") if val: item["status"] = "ok" item["msg"] = f"已配置（{val[:8]}...）" else: item["status"] = "fail" if required else "warn" item["msg"] = "未设置" + ("（必填）" if required else "（可选，按需配）") out["items"].append(item) return out SERVICES = [ ("ComfyUI", os.environ.get("COMFYUI_URL", "http://127.0.0.1:8188"), "/system_stats"), ("SD WebUI", os.environ.get("SDWEBUI_URL", "http://127.0.0.1:7860"), "/sdapi/v1/options"), ] def check_services(skip_network: bool = False) -> Dict: out = {"category": "local_services", "items": []} if skip_network: out["skipped"] = True return out for name, url, probe_path in SERVICES: item = {"name": name, "url": url} try: from urllib.parse import urljoin full = urljoin(url, probe_path) req = Request(full) with urlopen(req, timeout=2) as r: item["status"] = "ok" item["msg"] = f"{r.status} {r.reason}" except (HTTPError, URLError, socket.timeout, ConnectionResetError, OSError) as e: item["status"] = "warn" item["msg"] = f"未启动或不可达（按需启）" out["items"].append(item) return out def check_obsidian() -> Dict: out = {"category": "obsidian", "items": []} candidates = [ ("$OBSIDIAN_VAULT", os.environ.get("OBSIDIAN_VAULT", "")), ("~/knowledge/huo15", os.path.expanduser("~/knowledge/huo15")), ("~/Documents/Obsidian", os.path.expanduser("~/Documents/Obsidian")), ("~/Obsidian", os.path.expanduser("~/Obsidian")), ] found_any = False for label, path in candidates: item = {"label": label, "path": path or "(未设置)"} if path and os.path.isdir(path): item["status"] = "ok" item["msg"] = "存在" found_any = True else: item["status"] = "info" item["msg"] = "不存在或未设置" out["items"].append(item) out["any_vault_found"] = found_any return out PERSIST_DIRS = [ ("characters", "~/.huo15/characters", "角色卡"), ("sessions", "~/.huo15/sessions", "session（多轮编辑）"), ("brand_kits", "~/.huo15/brand_kits", "品牌套件"), ("learned_presets", "~/.huo15/learned_presets", "风格学习预设"), ] def check_persisted() -> Dict: out = {"category": "persisted_assets", "items": []} for key, path, label in PERSIST_DIRS: full = os.path.expanduser(path) item = {"key": key, "path": full, "label": label} if os.path.isdir(full): files = [f for f in os.listdir(full) if f.endswith(".json")] item["status"] = "ok" if files else "info" item["count"] = len(files) item["msg"] = f"{len(files)} 个" if files else "暂无" item["names"] = [f[:-5] for f in sorted(files)[:10]] else: item["status"] = "info" item["msg"] = "目录不存在（首次使用时自动创建）" item["count"] = 0 out["items"].append(item) return out def check_anthropic_ping(skip_network: bool = False) -> Dict: """轻量调一次 Claude API（最便宜的 haiku，单 token）验证 key 有效。""" out = {"category": "anthropic_ping"} if skip_network: out["status"] = "skipped" return out api_key = os.environ.get("ANTHROPIC_API_KEY") if not api_key: out["status"] = "warn" out["msg"] = "未设置 ANTHROPIC_API_KEY" return out try: body = { "model": "claude-haiku-4-5", "max_tokens": 10, "messages": [{"role": "user", "content": "ping"}], } req = Request( "https://api.anthropic.com/v1/messages", data=json.dumps(body).encode("utf-8"), headers={ "Content-Type": "application/json", "x-api-key": api_key, "anthropic-version": "2023-06-01", }, method="POST", ) with urlopen(req, timeout=15) as r: resp = json.loads(r.read().decode("utf-8")) if "content" in resp: out["status"] = "ok" out["msg"] = f"模型 {resp.get('model', '?')} 响应正常" out["usage"] = resp.get("usage", {}) else: out["status"] = "fail" out["msg"] = f"响应异常: {resp}" except HTTPError as e: body = e.read().decode("utf-8", errors="replace")[:200] out["status"] = "fail" out["msg"] = f"HTTP {e.code}: {body}" except Exception as e: out["status"] = "fail" out["msg"] = f"调用失败: {e}" return out # ───────────────────────────────────────────────────────── # 输出 # ───────────────────────────────────────────────────────── def print_section(title: str, data: Dict): print(f"\n{BOLD}{title}{RESET}") print("─" * 60) if data.get("skipped"): print(info("已跳过（--quick）")) return if "items" not in data: # 单项结果 status = data.get("status", "info") msg = data.get("msg", "") line_fn = {"ok": ok, "warn": warn, "fail": fail, "skipped": info}.get(status, info) print(line_fn(msg)) if data.get("usage"): u = data["usage"] print(info(f" in={u.get('input_tokens', 0)} / out={u.get('output_tokens', 0)} tokens")) return for item in data["items"]: status = item.get("status", "info") line_fn = {"ok": ok, "warn": warn, "fail": fail, "missing": fail, "info": info}.get(status, info) if data["category"] == "scripts": label = f"{item['name']:18s} v{item.get('version', '?')}" if status != "ok": label += f" — {item.get('msg', '')}" print(line_fn(label)) elif data["category"] == "api_keys": label = f"{item['env']:25s} {item.get('msg', '')} {GRAY}({item['desc']}){RESET}" print(line_fn(label)) elif data["category"] == "local_services": print(line_fn(f"{item['name']:12s} {item['url']:38s} {item.get('msg', '')}")) elif data["category"] == "obsidian": print(line_fn(f"{item['label']:30s} {item.get('msg', '')}")) elif data["category"] == "persisted_assets": line = f"{item['label']:18s} {item.get('msg', ''):8s}" if item.get("names"): line += f" {GRAY}({', '.join(item['names'][:5])}){RESET}" print(line_fn(line)) def collect_summary(checks: List[Dict]) -> Dict: """统计 ok / warn / fail 总数。""" counts = {"ok": 0, "warn": 0, "fail": 0, "info": 0} for c in checks: if c.get("skipped"): continue if "items" in c: for item in c["items"]: s = item.get("status", "info") counts[s if s in counts else "info"] = counts.get(s, 0) + 1 else: s = c.get("status", "info") if s in counts: counts[s] += 1 return counts def main(): parser = argparse.ArgumentParser( description=f"huo15-img-prompt doctor v{VERSION} — 健康检查", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=""" 示例: doctor.py # 全量检查 doctor.py --quick # 跳过网络测试 doctor.py --check api # 只查 API keys doctor.py --check scripts # 只查脚本 doctor.py -j # JSON 输出 """, ) parser.add_argument("--quick", action="store_true", help="跳过网络测试（service/anthropic_ping）") parser.add_argument("--check", choices=["scripts", "api", "services", "obsidian", "persisted", "ping"], help="只跑指定项") parser.add_argument("-j", "--json", action="store_true", help="JSON 输出") parser.add_argument("-v", "--version", action="version", version=f"%(prog)s v{VERSION}") args = parser.parse_args() runners = { "scripts": ("脚本完整性", check_scripts, []), "api": ("API Keys", check_api_keys, []), "services": ("本地后端服务", check_services, [args.quick]), "obsidian": ("Obsidian Vault", check_obsidian, []), "persisted": ("持久化资产", check_persisted, []), "ping": ("Claude API 实测", check_anthropic_ping, [args.quick]), } if args.check: keys = [args.check] else: keys = list(runners.keys()) results = {} for k in keys: title, fn, fn_args = runners[k] results[k] = fn(*fn_args) results[k]["_title"] = title if args.json: print(json.dumps({"version": VERSION, "results": results}, ensure_ascii=False, indent=2)) return print(f"\n{BOLD}🩺 huo15-img-prompt doctor v{VERSION}{RESET}") for k in keys: print_section(results[k]["_title"], results[k]) counts = collect_summary(list(results.values())) total = sum(counts.values()) print(f"\n{BOLD}总结{RESET}") print("─" * 60) print(f" {GREEN}✓ {counts['ok']}{RESET} {YELLOW}⚠ {counts['warn']}{RESET} {RED}✗ {counts['fail']}{RESET} {GRAY}· {counts['info']}{RESET} / {total}") if counts["fail"] > 0: print(f"\n{RED}有 {counts['fail']} 个失败项。修复建议见上方 ✗ 标记。{RESET}\n") sys.exit(1) elif counts["warn"] > 0: print(f"\n{YELLOW}部分功能受限（warn），按需配置。{RESET}\n") else: print(f"\n{GREEN}全部正常 🎉{RESET}\n") if __name__ == "__main__": main() FILE:scripts/enhance_prompt.py #!/usr/bin/env python3 """ huo15-img-prompt — T2I 提示词增强脚本 v2.2 核心能力： 1. 88 风格预设（摄影 / 动漫 / 插画 / 3D / 设计 / 艺术 / 场景 / 游戏 / 东方传统九大类） 2. 意图解析（主体类型 / 画幅 / 构图 / 情绪 / 时间 / 天气 / 季节） 3. 一致性五锁（camera + lighting + palette + aspect + seed） 4. 系列批量模式（-s N：共享锁，差异化动作） 5. 角色设定图模式（--character-sheet：T-pose 多视图，喂给 MJ --cref） 6. 质量档位（-t basic / pro / master） 7. 负向需求识别（"不要 X" / "no X" / "avoid X" 自动入负面） 8. 多模型精细化适配（Midjourney / SD / SDXL / Flux / DALL-E 3） 9. 别名 & 中英混输入（anime / cyberpunk / 原神 / 敦煌均可） 10. 混合预设 v2.2：`-p A+B --mix 0.6` 加权融合两套风格（赛博+水墨 / 原神+敦煌 ...） """ import sys import os import json import re import argparse import hashlib from typing import Dict, List, Optional, Tuple VERSION = "3.1.0" # CLIP token 限制（SDXL/SD 1.5 默认 77 token，超过会被截断） CLIP_TOKEN_LIMIT = 77 # 粗略估算：英文 1.3 token/word, 中文 1 token/字 def estimate_tokens(text: str) -> int: """粗估 prompt 的 CLIP token 数量。""" if not text: return 0 chinese_chars = sum(1 for c in text if "一" <= c <= "鿿") english_words = len([w for w in re.findall(r"[a-zA-Z]+", text)]) other = len(re.findall(r"[0-9.,()\-:;]", text)) return chinese_chars + int(english_words * 1.3) + other // 3 # ───────────────────────────────────────────────────────── # Obsidian 集成（v2.6 D2）— recipe 写入 vault # ───────────────────────────────────────────────────────── def find_obsidian_vault() -> Optional[str]: """检测 Obsidian vault 路径（按优先级）。""" # 1. 环境变量 env_vault = os.environ.get("OBSIDIAN_VAULT") if env_vault and os.path.isdir(os.path.expanduser(env_vault)): return os.path.expanduser(env_vault) # 2. 用户记忆里的常用位置 candidates = [ "~/knowledge/huo15", "~/Documents/Obsidian", "~/Obsidian", "~/Documents/knowledge", ] for c in candidates: p = os.path.expanduser(c) if os.path.isdir(p): return p return None def write_obsidian_recipe(result: Dict, subdir: str = "图集") -> str: """把 recipe 写到 Obsidian vault 的 markdown 文件。""" vault = find_obsidian_vault() if not vault: raise RuntimeError("找不到 Obsidian vault（设 OBSIDIAN_VAULT 环境变量）") target_dir = os.path.join(vault, subdir) os.makedirs(target_dir, exist_ok=True) import time as _time date_str = _time.strftime("%Y-%m-%d", _time.localtime()) subject = result.get("original", "untitled") slug = re.sub(r"[^\w一-鿿]+", "_", subject)[:40] or "untitled" fn = f"{date_str}-{slug}-{result.get('seed_suggestion', '0')}.md" path = os.path.join(target_dir, fn) # frontmatter fm = { "tags": ["huo15-img-prompt", "t2i", result.get("preset", "")], "preset": result.get("preset", ""), "model": result.get("model", ""), "aspect": result.get("aspect", ""), "seed": result.get("seed_suggestion", ""), "tier": result.get("quality_tier", "pro"), "version": result.get("version", VERSION), "date": date_str, } if result.get("mix_label"): fm["mix"] = result["mix_label"] fm_lines = ["---"] for k, v in fm.items(): if isinstance(v, list): fm_lines.append(f"{k}: [{', '.join(str(x) for x in v if x)}]") else: fm_lines.append(f"{k}: {v}") fm_lines.append("---") body = [ f"# {subject}", "", f"> 由火一五文生图提示词 v{VERSION} 生成", "", "## 原始描述", "", result.get("original", ""), "", "## 正向提示词", "", "```", result.get("positive", ""), "```", "", "## 负向提示词", "", "```", result.get("negative", ""), "```", "", "## 一致性锁", "", ] for k, v in (result.get("consistency_lock") or {}).items(): if v: body.append(f"- **{k}**: {v}") body.extend(["", "## 元信息", ""]) if result.get("composition"): body.append(f"- 构图: {result['composition']}") if result.get("mood"): body.append(f"- 情绪: {result['mood']}") if result.get("time_of_day"): body.append(f"- 时间: {result['time_of_day']}") if result.get("weather"): body.append(f"- 天气: {result['weather']}") if result.get("season"): body.append(f"- 季节: {result['season']}") # Claude polish 信息 if result.get("claude_polish"): body.extend(["", "## Claude 润色记录", "", f"- 模型: {result['claude_polish'].get('_model', '?')}", f"- 说明: {result['claude_polish'].get('polish_notes', '')}"]) # Image review 信息 if result.get("image_review"): ir = result["image_review"] body.extend(["", "## VLM 评审", "", f"- 综合: **{ir.get('overall_score', 0):.1f}/10** ({ir.get('verdict', '?')})", f"- 总结: {ir.get('summary', '')}"]) body.extend(["", "## CLI", "", "```bash", f"# 复现这张图", f"enhance_prompt.py \"{result.get('original', '')}\" -p {result.get('preset', '')} -a {result.get('aspect', '')} --seed {result.get('seed_suggestion', '')}", "```"]) content = "\n".join(fm_lines + [""] + body) + "\n" with open(path, "w", encoding="utf-8") as f: f.write(content) return path # ───────────────────────────────────────────────────────── # Session 持久化（v2.4 A2）— 多轮编辑模式 # ───────────────────────────────────────────────────────── SESSION_DIR = os.path.expanduser("~/.huo15/sessions") def session_path(name: str) -> str: safe = re.sub(r"[^\w\-]", "_", name) return os.path.join(SESSION_DIR, f"{safe}.json") def session_load(name: str) -> Optional[Dict]: """加载 session，不存在返回 None。""" p = session_path(name) if not os.path.isfile(p): return None try: with open(p, "r", encoding="utf-8") as f: return json.load(f) except (json.JSONDecodeError, IOError): return None def session_save(name: str, state: Dict): """保存 session（追加 iteration 历史）。""" os.makedirs(SESSION_DIR, exist_ok=True) p = session_path(name) existing = session_load(name) or {"name": name, "iterations": []} iteration = { "timestamp": int(__import__("time").time()), "subject": state.get("original") or state.get("subject", ""), "preset": state.get("preset", ""), "mix_secondary": state.get("mix_secondary", ""), "mix_ratio": state.get("mix_ratio"), "aspect": state.get("aspect", ""), "model": state.get("model", ""), "mood": state.get("mood", ""), "composition": state.get("composition", ""), "seed": state.get("seed_suggestion"), "tier": state.get("quality_tier", "pro"), } existing["iterations"].append(iteration) existing["latest"] = iteration existing["count"] = len(existing["iterations"]) with open(p, "w", encoding="utf-8") as f: json.dump(existing, f, ensure_ascii=False, indent=2) def session_apply(name: str, args) -> Dict: """从 session 加载 latest，把 args 中未指定的字段用 session 值填充。""" sess = session_load(name) if not sess: return {"loaded": False, "reason": f"session '{name}' 不存在"} latest = sess.get("latest") or {} # 仅在 CLI 未显式指定时应用 session 默认值 applied = [] if not args.subject and latest.get("subject"): args.subject = latest["subject"] applied.append(f"subject={args.subject}") if not args.preset and latest.get("preset"): if latest.get("mix_secondary"): args.preset = f"{latest['preset']}+{latest['mix_secondary']}" else: args.preset = latest["preset"] applied.append(f"preset={args.preset}") if not args.aspect and latest.get("aspect"): args.aspect = latest["aspect"] applied.append(f"aspect={args.aspect}") if args.model == "通用" and latest.get("model"): args.model = latest["model"] applied.append(f"model={args.model}") if not args.mood and latest.get("mood"): args.mood = latest["mood"] if not args.composition and latest.get("composition"): args.composition = latest["composition"] if args.seed is None and latest.get("seed"): args.seed = latest["seed"] applied.append(f"seed={args.seed} (锁定一致性)") return { "loaded": True, "name": name, "applied_from_session": applied, "iteration_count": sess.get("count", 0), } def session_list(): if not os.path.isdir(SESSION_DIR): print("\n📭 暂无 session（在 ~/.huo15/sessions/）\n") return print(f"\n📚 现有 sessions ({SESSION_DIR}):") for fn in sorted(os.listdir(SESSION_DIR)): if not fn.endswith(".json"): continue p = os.path.join(SESSION_DIR, fn) try: with open(p, "r", encoding="utf-8") as f: d = json.load(f) latest = d.get("latest", {}) count = d.get("count", 0) print(f" • {d.get('name', fn[:-5])}: {count} 轮") print(f" 最近: '{latest.get('subject', '')}' [{latest.get('preset', '')}]") except (json.JSONDecodeError, IOError): print(f" • {fn} (损坏)") print() # 预设搜索词典（v2.4 F1）— 中文预设 → 海外平台搜索关键词 PRESET_SEARCH_TERMS: Dict[str, str] = { "写实摄影": "photorealistic portrait dslr", "胶片摄影": "kodak portra film grain", "黑白摄影": "black and white photography fine art", "人像摄影": "portrait photography 85mm", "时尚大片": "vogue editorial fashion photography", "美食摄影": "food photography overhead", "产品摄影": "product photography white background", "微距摄影": "macro photography insect close up", "航拍摄影": "aerial drone photography", "街拍纪实": "street photography candid", "暗黑美食": "moody dark food photography", "日杂": "japanese lifestyle magazine photography", "街头潮流": "streetwear hypebeast photography", "动漫": "anime illustration", "新海诚": "makoto shinkai anime", "宫崎骏": "studio ghibli miyazaki", "美漫": "western comic book art", "Q版": "chibi character", "童话绘本": "children book illustration", "萌系": "moe anime cute", "厚涂": "anime thick paint detailed", "轻小说封面": "light novel cover illustration", "赛璐璐": "cel shaded anime", "水彩": "watercolor painting", "油画": "oil painting classical", "水墨": "chinese ink wash sumi", "工笔国画": "gongbi chinese painting", "浮世绘": "ukiyo-e woodblock", "线稿": "line art sketch", "像素艺术": "pixel art 16-bit", "3DC4D": "cinema 4d render octane", "盲盒手办": "blind box figurine cute 3d", "低多边形": "low poly 3d", "等距视图": "isometric illustration", "粘土": "claymation 3d render", "毛毡手工": "felt wool craft", "纸艺": "paper craft origami", "极简主义": "minimalist design", "平面设计": "graphic design poster", "Logo设计": "logo design minimalist", "图标设计": "icon design flat", "信息图": "infographic design", "品牌KV": "brand key visual", "专辑封面": "album cover art", "复古海报": "vintage poster art", "电影海报": "movie poster cinematic", "表情包": "sticker emoji design", "玻璃拟态": "glassmorphism ui", "新拟态": "neumorphism soft ui", "孟菲斯": "memphis design 80s", "杂志编排": "editorial magazine layout", "包豪斯": "bauhaus design", "奶油风": "korean soft cream design", "印象派": "impressionist monet", "后印象派": "post impressionist van gogh", "新艺术": "art nouveau mucha", "装饰艺术": "art deco gatsby", "赛博朋克": "cyberpunk neon city", "蒸汽朋克": "steampunk brass gears", "科幻": "sci-fi space opera", "奇幻": "fantasy art epic", "黑暗奇幻": "dark fantasy berserk", "国潮": "guochao chinese trend", "Y2K": "y2k aesthetic 2000s", "Vaporwave": "vaporwave aesthetic", "霓虹灯牌": "neon sign aesthetic", "建筑可视化": "architectural visualization", "电影感": "cinematic film still anamorphic", "概念艺术": "concept art illustration", "粗野主义": "brutalism architecture concrete", "北欧极简": "nordic scandinavian minimal", "侘寂": "wabi sabi japanese aesthetic", "疗愈治愈": "cozy healing aesthetic", "美式复古": "americana retro vintage", "原神": "genshin impact mihoyo", "崩铁星穹": "honkai star rail", "英雄联盟": "league of legends splash art", "暗黑4": "diablo 4 dark fantasy", "Valorant": "valorant agent splash", "Pokemon": "pokemon art official", "暴雪风": "blizzard art world of warcraft", "敦煌壁画": "dunhuang mural tang dynasty", "青花瓷": "blue and white porcelain", "民国月份牌": "republic of china calendar girl", "年画": "chinese new year nianhua", "剪纸": "chinese paper cut", "和风": "japanese wafu aesthetic", "汉服写真": "hanfu portrait chinese", } def preset_example_urls(preset: str) -> Dict[str, str]: """生成预设的参考图搜索 URL（实时有效，零维护）。""" term = PRESET_SEARCH_TERMS.get(preset, preset) encoded = re.sub(r"\s+", "+", term) return { "lexica": f"https://lexica.art/?q={encoded}", "civitai": f"https://civitai.com/search/images?query={encoded}", "pinterest": f"https://www.pinterest.com/search/pins/?q={encoded}", "google_images": f"https://www.google.com/search?tbm=isch&q={encoded}", "unsplash": f"https://unsplash.com/s/photos/{encoded}", } def compact_prompt(positive: str, target_tokens: int = CLIP_TOKEN_LIMIT, keep_head: int = 6) -> Tuple[str, Dict]: """v2.4: 压缩 prompt 到 CLIP 限制内。策略： 1. 主体（前 keep_head 个 token）必保 2. quality 词（masterpiece, best quality, 8k 等）保留 1 个 3. 重复/同义词去重 4. 按权重保留：camera > subject > lighting > palette > extras > quality """ tokens = estimate_tokens(positive) if tokens <= target_tokens: return positive, {"compacted": False, "estimated_tokens": tokens} # 拆 token（按 , 分隔） parts = [p.strip() for p in positive.split(",") if p.strip()] if len(parts) <= 3: return positive, {"compacted": False, "estimated_tokens": tokens, "reason": "too few parts"} # 1. 去重（大小写不敏感） seen = set() deduped = [] for p in parts: key = p.lower().replace(" ", "") if key not in seen: seen.add(key) deduped.append(p) # 2. 同义压缩 QUALITY_SYNS = {"masterpiece", "best quality", "ultra detailed", "8k", "high quality", "highly detailed", "intricate details", "sharp focus"} quality_kept = False filtered = [] for p in deduped: plow = p.lower() if any(s in plow for s in QUALITY_SYNS): if not quality_kept: filtered.append(p) quality_kept = True continue filtered.append(p) # 3. 估算并截断 out: List[str] = [] cur_tokens = 0 head_count = min(keep_head, len(filtered)) for p in filtered[:head_count]: # 必保头 out.append(p) cur_tokens += estimate_tokens(p) + 1 for p in filtered[head_count:]: t = estimate_tokens(p) + 1 if cur_tokens + t > target_tokens: break out.append(p) cur_tokens += t new_prompt = ", ".join(out) return new_prompt, { "compacted": True, "estimated_tokens_before": tokens, "estimated_tokens_after": cur_tokens, "parts_before": len(parts), "parts_after": len(out), "removed": len(parts) - len(out), } # ───────────────────────────────────────────────────────── # 通用质量 / 负面词 # ───────────────────────────────────────────────────────── UNIVERSAL_QUALITY = "masterpiece, best quality, ultra detailed, 8k" UNIVERSAL_NEG = ( "low quality, worst quality, lowres, blurry, jpeg artifacts, " "watermark, signature, text, logo, username, " "bad anatomy, bad hands, extra fingers, missing fingers, " "extra limbs, deformed, mutated, disfigured, ugly, " "out of frame, cropped, duplicate" ) # 这些预设天然需要 logo / text / signature，把它们从全局负面词中剔除，避免语义冲突 PRESET_NEG_EXCLUDE: Dict[str, List[str]] = { "Logo设计": ["logo", "text"], "图标设计": ["logo", "text"], "表情包": ["text"], "复古海报": ["text"], "电影海报": ["text"], "专辑封面": ["text"], "品牌KV": ["text"], "信息图": ["text"], "水墨": ["signature"], "工笔国画": ["signature"], "浮世绘": ["text", "signature"], "霓虹灯牌": ["text"], } def _filter_neg(universal: str, exclude: List[str]) -> str: if not exclude: return universal tokens = [t.strip() for t in universal.split(",")] kept = [t for t in tokens if t.lower() not in {e.lower() for e in exclude}] return ", ".join(kept) # ───────────────────────────────────────────────────────── # 风格预设 — 每个预设 7 个字段 # tags 风格标签 # quality 画质标签 # neg 负面标签（与 UNIVERSAL_NEG 合并） # camera 机位 / 镜头（摄影专用，其它留空） # lighting 光影锁 # palette 色板锁（系列一致性关键） # aspect 默认画幅 # ───────────────────────────────────────────────────────── STYLE_PRESETS: Dict[str, Dict[str, str]] = { # ========== 摄影 Photography ========== "写实摄影": { "category": "摄影", "tags": "photorealistic, hyperrealistic, dslr photography, sharp focus", "quality": "raw photo, detailed skin texture, film grain subtle", "neg": "cartoon, anime, painting, drawing, illustration, cgi", "camera": "Canon EOS R5, 85mm f/1.4 lens, shallow depth of field", "lighting": "professional studio lighting, softbox key light, rim light", "palette": "natural color grading, balanced exposure", "aspect": "3:4", }, "胶片摄影": { "category": "摄影", "tags": "analog film photography, film grain, analog aesthetic", "quality": "kodak portra 400 film stock, scanned film", "neg": "digital, oversaturated, hdr, plastic skin", "camera": "35mm film camera, 50mm prime, shot on film", "lighting": "natural window light, golden hour", "palette": "muted earth tones, slightly faded film colors", "aspect": "3:2", }, "黑白摄影": { "category": "摄影", "tags": "black and white photography, monochrome, high contrast", "quality": "silver gelatin print, fine art photography, rich grayscale", "neg": "color, colorful, saturated, low contrast", "camera": "Leica M6, 35mm f/2, classic reportage framing", "lighting": "dramatic chiaroscuro, strong directional light", "palette": "pure black and white, deep blacks, crisp whites", "aspect": "1:1", }, "人像摄影": { "category": "摄影", "tags": "portrait photography, shallow depth of field, bokeh background", "quality": "flawless skin retouch, detailed eyes, catch light", "neg": "full body, wide shot, plastic skin, uncanny", "camera": "85mm f/1.4, eye-level portrait, rule of thirds", "lighting": "rembrandt lighting, soft key with fill", "palette": "warm skin tones, complementary backdrop", "aspect": "3:4", }, "时尚大片": { "category": "摄影", "tags": "high fashion editorial, vogue style, avant-garde styling", "quality": "magazine cover quality, haute couture", "neg": "amateur, casual, snapshot, cluttered set", "camera": "medium format, 50mm, full body or waist-up", "lighting": "hard strobe with deep shadows, beauty dish", "palette": "high-contrast, bold monochromatic set", "aspect": "3:4", }, "美食摄影": { "category": "摄影", "tags": "food photography, overhead flatlay, appetizing presentation", "quality": "detailed steam and texture, drool-worthy, michelin plating", "neg": "greasy, unappealing, blurry plate, messy", "camera": "macro 100mm, 45-degree angle or top-down", "lighting": "soft window light from side, subtle rim highlight", "palette": "warm appetite-triggering tones, natural food colors", "aspect": "1:1", }, "产品摄影": { "category": "摄影", "tags": "commercial product photography, clean composition, minimal scene", "quality": "crisp reflections, seamless background, advertising grade", "neg": "cluttered, messy background, amateur lighting", "camera": "90mm macro, eye-level product shot", "lighting": "large softbox key, gradient sweep background", "palette": "neutral white or brand-matched seamless", "aspect": "1:1", }, "微距摄影": { "category": "摄影", "tags": "macro photography, extreme close-up, micro world", "quality": "razor sharp details at micro scale, focus stacking", "neg": "soft focus, wide view, lack of detail", "camera": "100mm macro lens, 1:1 magnification", "lighting": "ring flash or twin macro flash, even diffused", "palette": "nature-true colors, intense saturation", "aspect": "1:1", }, "航拍摄影": { "category": "摄影", "tags": "aerial photography, drone shot, bird's eye view", "quality": "ultra wide sweeping vista, high altitude clarity", "neg": "ground level, close-up, people center frame", "camera": "drone camera, 24mm equivalent, top-down or 45-degree", "lighting": "natural sunlight, long soft shadows", "palette": "earth tones with atmospheric blue haze", "aspect": "16:9", }, "街拍纪实": { "category": "摄影", "tags": "street photography, decisive moment, candid documentary", "quality": "authentic raw feeling, unposed human story", "neg": "staged, fake, overprocessed", "camera": "35mm prime, hip-level snap, off-center subject", "lighting": "available ambient light, urban neon or sunlight", "palette": "slightly desaturated urban tones", "aspect": "3:2", }, # ========== 动漫 / 插画 Illustration ========== "动漫": { "category": "动漫", "tags": "anime style, cel shading, clean line art, vibrant anime colors", "quality": "detailed anime eyes, pixiv trending, high quality anime", "neg": "photorealistic, 3d render, western cartoon, low quality", "camera": "", "lighting": "anime-style soft light, rim light on hair", "palette": "vibrant saturated anime palette", "aspect": "3:4", }, "新海诚": { "category": "动漫", "tags": "Makoto Shinkai style, volumetric cloudscape, realistic anime backgrounds", "quality": "your name aesthetic, weathering with you mood, incredibly detailed skyscape", "neg": "flat background, dark mood, gritty", "camera": "", "lighting": "magic hour sunlight streaming, god rays through clouds", "palette": "sky blue, warm orange sunset, pink hour", "aspect": "16:9", }, "宫崎骏": { "category": "动漫", "tags": "Studio Ghibli style, hand-painted background, whimsical warmth", "quality": "Totoro aesthetic, Spirited Away mood, hayao miyazaki inspired", "neg": "dark, edgy, hyperdetailed, cgi", "camera": "", "lighting": "soft daylight through leaves, gentle diffuse", "palette": "pastoral greens, cream, sky blue", "aspect": "16:9", }, "美漫": { "category": "动漫", "tags": "American comic book style, bold ink lines, halftone shading", "quality": "marvel / DC inspired, dynamic pose, action panel", "neg": "anime, soft shading, watercolor", "camera": "", "lighting": "dramatic cel lighting, high contrast shadows", "palette": "saturated primary colors, comic book palette", "aspect": "2:3", }, "Q版": { "category": "动漫", "tags": "chibi style, super-deformed, cute mascot, 3-head-tall proportions", "quality": "adorable, clean vector look, sticker worthy", "neg": "realistic proportion, detailed anatomy, dark mood", "camera": "", "lighting": "even flat light, gentle cel shading", "palette": "bright pastel palette, sugary", "aspect": "1:1", }, "童话绘本": { "category": "动漫", "tags": "children's book illustration, storybook style, hand drawn warmth", "quality": "gouache texture, paper warmth, beatrix potter meets pixar", "neg": "dark, horror, hyper-realistic, edgy", "camera": "", "lighting": "soft overall illumination, enchanted glow", "palette": "warm buttery pastels, cream page base", "aspect": "4:3", }, "水彩": { "category": "插画", "tags": "watercolor painting, wet-on-wet technique, paper texture, soft bleeding edges", "quality": "traditional watercolor, transparent wash layers, artistic", "neg": "digital vector, hard edges, heavy outlines, 3d", "camera": "", "lighting": "natural daylight on paper", "palette": "translucent pastel layers, white paper showing through", "aspect": "1:1", }, "油画": { "category": "插画", "tags": "oil painting, thick impasto brushstrokes, canvas texture", "quality": "museum quality oil on canvas, old master technique", "neg": "digital, flat colors, vector, pixel art", "camera": "", "lighting": "chiaroscuro, warm rembrandt glow", "palette": "rich earth tones, deep jewel colors", "aspect": "4:5", }, "水墨": { "category": "插画", "tags": "Chinese ink wash painting, sumi-e, negative space, calligraphic strokes", "quality": "zen atmosphere, rice paper texture, ink bleed", "neg": "colorful, dense composition, western painting, cartoon", "camera": "", "lighting": "flat paper light, no harsh shadows", "palette": "sumi black on rice-paper beige, occasional vermillion seal", "aspect": "3:4", }, "工笔国画": { "category": "插画", "tags": "Chinese gongbi painting, meticulous fine brush, intricate floral detail", "quality": "Song dynasty court painting style, mineral pigment", "neg": "loose brushstrokes, abstract, western style", "camera": "", "lighting": "flat even pigment, no modeling light", "palette": "azurite blue, malachite green, cinnabar red, gold leaf", "aspect": "3:4", }, "浮世绘": { "category": "插画", "tags": "Ukiyo-e woodblock print, Edo period, Hokusai / Hiroshige style", "quality": "traditional Japanese woodcut, flat color blocks, outlined figures", "neg": "modern anime, 3d, photorealistic", "camera": "", "lighting": "no modeling light, flat graphic", "palette": "prussian blue, earth reds, muted greens", "aspect": "2:3", }, "线稿": { "category": "插画", "tags": "clean line art, black ink on white, single weight or dynamic line", "quality": "architectural line drawing precision, tattoo flash clarity", "neg": "color, shading, painterly, texture", "camera": "", "lighting": "no lighting, pure linework", "palette": "pure black on white", "aspect": "1:1", }, "像素艺术": { "category": "插画", "tags": "pixel art, 16-bit sprite, pixelated, retro game aesthetic", "quality": "clean pixel clusters, limited palette, dithering", "neg": "anti-aliased, smooth, photorealistic, 3d render, high resolution", "camera": "", "lighting": "flat pixel shading or 2-tone", "palette": "NES / SNES limited palette, 16 colors", "aspect": "1:1", }, # ========== 3D / 手工 3D & Craft ========== "3DC4D": { "category": "3D", "tags": "3d render, octane render, c4d style, subsurface scattering, glossy materials", "quality": "ray traced reflections, detailed shader, behance trending", "neg": "2d flat, sketch, line art", "camera": "3d viewport camera, 50mm equivalent", "lighting": "hdri environment light, colored accent rims", "palette": "vibrant candy colors, pastel gradients", "aspect": "1:1", }, "盲盒手办": { "category": "3D", "tags": "blind box figurine, pop mart style, chibi 3d toy, kawaii collectible", "quality": "vinyl toy finish, pristine product shot, pop mart aesthetic", "neg": "realistic human, gritty, damaged", "camera": "50mm product shot, eye level toy perspective", "lighting": "soft studio light, gentle rim, clean shadow", "palette": "pastel macaron palette", "aspect": "1:1", }, "低多边形": { "category": "3D", "tags": "low poly 3d, faceted geometry, minimalist polygons", "quality": "crisp flat shaded polygons, geometric stylization", "neg": "high detail, smooth subdivisions, realistic", "camera": "3/4 perspective, isometric-ish", "lighting": "flat faceted shading, 2-3 light setup", "palette": "limited flat palette, often pastel", "aspect": "1:1", }, "等距视图": { "category": "3D", "tags": "isometric illustration, 2.5d isometric scene, game-dev isometric tile", "quality": "clean vector isometric look, detailed miniature diorama", "neg": "perspective distortion, top-down, first-person", "camera": "true isometric projection, 30-degree angles", "lighting": "even diffuse light, directional accent", "palette": "bright clean pastel palette", "aspect": "1:1", }, "粘土": { "category": "3D", "tags": "claymation style, stop motion clay, aardman-like tactile figures", "quality": "handmade clay texture, fingerprint detail", "neg": "clean digital, plastic, smooth 3d", "camera": "stop motion rig perspective, slight depth of field", "lighting": "warm tungsten key with practical fill", "palette": "warm terracotta tones", "aspect": "1:1", }, "毛毡手工": { "category": "3D", "tags": "felted wool craft, needle felt texture, handmade plush character", "quality": "fuzzy fiber detail, cute handmade imperfection", "neg": "smooth digital render, photorealistic animal", "camera": "close macro product shot", "lighting": "soft diffuse daylight", "palette": "muted natural wool colors", "aspect": "1:1", }, "纸艺": { "category": "3D", "tags": "paper craft, layered paper art, quilling, origami composition", "quality": "intricate cut paper layers, shadow depth between layers", "neg": "flat 2d, digital illustration", "camera": "front-on with slight tilt, shallow depth", "lighting": "rim light casting paper-edge shadows", "palette": "pastel construction paper colors", "aspect": "1:1", }, # ========== 设计 Design ========== "极简主义": { "category": "设计", "tags": "minimalist design, negative space, swiss style, geometric composition", "quality": "clean typography-friendly, editorial layout", "neg": "cluttered, ornate, busy, excess detail", "camera": "", "lighting": "flat studio light or ambient, no drama", "palette": "monochrome + single accent, lots of white", "aspect": "1:1", }, "平面设计": { "category": "设计", "tags": "flat design, vector graphic, bold shapes, brand illustration", "quality": "clean vectors, designer grade composition", "neg": "photorealistic, gradient 3d, sketchy", "camera": "", "lighting": "flat shading, no highlights", "palette": "brand-forward 3-color palette", "aspect": "1:1", }, "Logo设计": { "category": "设计", "tags": "logo design, brand mark, vector logotype, scalable emblem", "quality": "professional logo, centered composition on clean background", "neg": "photorealistic scene, complex background, cluttered", "camera": "", "lighting": "flat vector, no light gradient", "palette": "2-color max, high contrast", "aspect": "1:1", }, "图标设计": { "category": "设计", "tags": "icon design, app icon, rounded square, centered glyph", "quality": "apple hig compliant, clean icon grid, crisp at 1024px", "neg": "cluttered, off-center, photo, low contrast", "camera": "", "lighting": "subtle highlight gradient, soft inner glow", "palette": "vibrant gradient with 2-3 colors", "aspect": "1:1", }, "信息图": { "category": "设计", "tags": "infographic design, data visualization, icon system, explanatory layout", "quality": "clean editorial infographic, behance level", "neg": "messy, illustrative painting, photograph", "camera": "", "lighting": "flat, no drama", "palette": "brand palette + grayscale structure", "aspect": "3:4", }, "品牌KV": { "category": "设计", "tags": "brand key visual, advertising campaign hero image, marketing KV", "quality": "commercial campaign quality, headline-ready negative space", "neg": "casual, amateur, low contrast", "camera": "hero wide or 3/4 product hero", "lighting": "brand-defined dramatic key, colored rim", "palette": "brand palette dominant + accent", "aspect": "16:9", }, "专辑封面": { "category": "设计", "tags": "album cover art, music artwork, square format composition", "quality": "iconic album design, strong concept, emotive", "neg": "cluttered, literal, stock imagery", "camera": "", "lighting": "concept-driven, mood-heavy", "palette": "2-3 color highly intentional palette", "aspect": "1:1", }, "复古海报": { "category": "设计", "tags": "vintage poster design, 1950s retro, letterpress print, screenprint texture", "quality": "saul bass meets mid-century, weathered paper feel", "neg": "modern flat design, digital gradient, 3d render", "camera": "", "lighting": "flat two-tone", "palette": "muted primary + cream background", "aspect": "3:4", }, "电影海报": { "category": "设计", "tags": "movie poster, cinematic key art, title-ready composition", "quality": "theatrical one-sheet, dramatic hero composition", "neg": "casual snapshot, cluttered, amateur", "camera": "hero portrait or symmetric icon layout", "lighting": "strong single direction light, volumetric", "palette": "teal & orange or moody duotone", "aspect": "2:3", }, "表情包": { "category": "设计", "tags": "sticker design, emoji style, expressive meme-ready character", "quality": "transparent background ready, bold outline, readable at 128px", "neg": "complex scene, photorealistic, subtle", "camera": "", "lighting": "flat cel shading", "palette": "bright saturated 4-color", "aspect": "1:1", }, # ========== 艺术史 Art Movement ========== "印象派": { "category": "艺术", "tags": "impressionist painting, visible brushstrokes, plein air, monet inspired", "quality": "late 19th century impressionism, atmospheric perspective", "neg": "photorealistic, digital, sharp outlines", "camera": "", "lighting": "dappled natural light, sun-drenched scene", "palette": "broken color technique, complementary dabs", "aspect": "4:5", }, "后印象派": { "category": "艺术", "tags": "post-impressionist, van gogh style, expressive brushstroke, emotive color", "quality": "starry night swirls, dynamic brush texture", "neg": "realistic, photographic, flat", "camera": "", "lighting": "emotional not physical light", "palette": "bold yellows cobalt and burnt sienna", "aspect": "4:5", }, "新艺术": { "category": "艺术", "tags": "art nouveau, alphonse mucha, flowing organic lines, floral ornament border", "quality": "belle époque poster, feminine ornate frame", "neg": "geometric minimal, modern flat, 3d", "camera": "", "lighting": "flat even decorative light", "palette": "muted golds, soft earth tones, sage", "aspect": "2:3", }, "装饰艺术": { "category": "艺术", "tags": "art deco, 1920s geometric ornament, gatsby aesthetic, gold and black lacquer", "quality": "symmetric art deco pattern, streamline moderne elegance", "neg": "rustic, organic nouveau, grunge", "camera": "", "lighting": "strong geometric shadow play", "palette": "black gold ivory with emerald accents", "aspect": "2:3", }, # ========== 场景 / 氛围 Scene ========== "赛博朋克": { "category": "场景", "tags": "cyberpunk, neon-soaked, blade runner aesthetic, megacity dystopia, holographic ads", "quality": "detailed cyberpunk cityscape, rainy night ambiance", "neg": "rustic, medieval, natural countryside", "camera": "low angle wide, 24mm anamorphic", "lighting": "neon magenta and cyan rim, wet reflective streets", "palette": "magenta cyan black, neon highlights", "aspect": "21:9", }, "蒸汽朋克": { "category": "场景", "tags": "steampunk, brass gears and copper pipes, victorian industrial, airship era", "quality": "intricate clockwork detail, rich leather and patina", "neg": "clean sci-fi, modern, plastic", "camera": "", "lighting": "warm gaslight glow, smoky haze", "palette": "brass copper sepia, burgundy leather", "aspect": "3:2", }, "科幻": { "category": "场景", "tags": "sci-fi concept art, futuristic technology, clean spaceship interior, holographic UI", "quality": "blade runner 2049 palette, hard-sci-fi plausible", "neg": "medieval, fantasy magic, primitive", "camera": "cinematic wide, 21:9 framing", "lighting": "cool blue practical strips, volumetric haze", "palette": "cool blue cyan with warm accent", "aspect": "21:9", }, "奇幻": { "category": "场景", "tags": "epic fantasy art, magical atmosphere, artstation trending, tolkien inspired", "quality": "detailed fantasy concept, elven architecture, dragon-scale atmosphere", "neg": "modern city, cyberpunk, mundane", "camera": "epic wide establishing, 24mm", "lighting": "ethereal god rays through mist", "palette": "golden hour warm with magical cyan glow", "aspect": "16:9", }, "黑暗奇幻": { "category": "场景", "tags": "dark fantasy, grimdark, eldritch horror atmosphere, berserk aesthetic", "quality": "frank frazetta meets zdzisław beksiński", "neg": "cheerful, bright, cartoonish", "camera": "low angle hero or dread pov", "lighting": "blood moon crimson, torch flicker", "palette": "black crimson sickly green, rusted iron", "aspect": "2:3", }, "国潮": { "category": "场景", "tags": "guochao Chinese neo-trend, modern hanfu revival, oriental modernism", "quality": "contemporary Chinese style illustration, editorial fashion", "neg": "western medieval, european style", "camera": "", "lighting": "warm accent on oriental red-gold", "palette": "vermillion jade gold, ink black accents", "aspect": "3:4", }, "Y2K": { "category": "场景", "tags": "Y2K aesthetic, early 2000s digital, chrome bubble UI, frosted plastic", "quality": "low-fi cd-rom graphic, holographic stickers", "neg": "ultra clean modern, analog retro", "camera": "", "lighting": "glossy chrome highlights", "palette": "baby blue pink lilac, iridescent chrome", "aspect": "1:1", }, "Vaporwave": { "category": "场景", "tags": "vaporwave, retro 80s 90s computer graphics, roman bust, palm tree grid", "quality": "synthwave aesthetic, low-fi jpeg nostalgia", "neg": "modern clean, natural, high detail", "camera": "", "lighting": "sunset gradient, neon grid horizon", "palette": "hot pink teal purple, retro sunset", "aspect": "16:9", }, "霓虹灯牌": { "category": "场景", "tags": "neon sign typography, glowing tube letters, dark brick wall backdrop", "quality": "realistic neon glass tube glow, chromatic bloom", "neg": "daylight, printed sign, flat vector", "camera": "straight-on product shot, 50mm", "lighting": "self-emissive neon, dark ambient", "palette": "magenta cyan on deep black", "aspect": "3:2", }, "建筑可视化": { "category": "场景", "tags": "architectural visualization, V-Ray / Lumion render, interior design magazine", "quality": "award-winning archviz, photorealistic materials", "neg": "sketchy, doodle, distorted perspective", "camera": "wide 24mm architectural tilt-corrected", "lighting": "realistic sun study plus artificial, product-ready", "palette": "natural materials, neutral brand-defined", "aspect": "16:9", }, "电影感": { "category": "场景", "tags": "cinematic film still, anamorphic lens flare, letterboxed framing", "quality": "ARRI Alexa quality, professional color grade, movie still", "neg": "snapshot, amateur, flat lighting, instagram filter", "camera": "anamorphic 2.39:1 framing, low angle hero", "lighting": "motivated practical + volumetric haze", "palette": "teal & orange cinematic grade", "aspect": "21:9", }, "概念艺术": { "category": "场景", "tags": "concept art, matte painting, production design, pre-visualization", "quality": "ILM / weta concept sketch, narrative-driven composition", "neg": "finished illustration, cartoon, low detail", "camera": "cinematic wide establishing", "lighting": "narrative-lit hero with atmosphere", "palette": "mood-defined limited palette", "aspect": "21:9", }, # ========== 游戏艺术 Game Art (v2.1 新增) ========== "原神": { "category": "游戏", "tags": "Genshin Impact style, miHoYo aesthetic, stylized anime rendering, cel shaded 3d", "quality": "gacha game hero card quality, detailed anime character portrait", "neg": "photorealistic, western cartoon, gritty", "camera": "3/4 character hero shot, slightly upward angle", "lighting": "rim light on hair, soft key + colored fill", "palette": "vibrant saturated anime palette, element-themed accents", "aspect": "3:4", }, "崩铁星穹": { "category": "游戏", "tags": "Honkai Star Rail style, space fantasy JRPG anime, miHoYo rendering", "quality": "splash art quality, dynamic pose, elemental VFX", "neg": "photorealistic, rustic, medieval", "camera": "dynamic dutch angle hero shot", "lighting": "glowing elemental rim light", "palette": "cosmic gradient + neon accent", "aspect": "3:4", }, "英雄联盟": { "category": "游戏", "tags": "League of Legends splash art style, Riot Games painterly illustration", "quality": "champion splash quality, dramatic action pose", "neg": "anime chibi, flat vector, photo", "camera": "dynamic low angle hero pose", "lighting": "dramatic rim with colored ability VFX", "palette": "saturated fantasy palette with magical accent", "aspect": "16:9", }, "暗黑4": { "category": "游戏", "tags": "Diablo IV style, dark gothic fantasy, blizzard illustration", "quality": "ARPG splash quality, grim dark atmosphere", "neg": "cheerful, pastel, chibi, flat", "camera": "low-angle menacing hero shot", "lighting": "infernal red rim, volumetric fog", "palette": "charcoal black, ember red, corrupted green", "aspect": "3:2", }, "Valorant": { "category": "游戏", "tags": "Valorant agent art, stylized flat anime realism, Riot FPS aesthetic", "quality": "agent reveal quality, confident hero pose", "neg": "painterly fantasy, chibi", "camera": "3/4 hero standoff", "lighting": "clean cel shaded with colored ability glow", "palette": "agent signature color + urban neutral", "aspect": "3:4", }, "Pokemon": { "category": "游戏", "tags": "Pokemon style, Ken Sugimori illustration, round cute creature design", "quality": "Pokedex official art, clean cel shading", "neg": "gritty, realistic, complex anatomy", "camera": "3/4 creature portrait on white", "lighting": "flat cel shading with soft shadow", "palette": "clean primary colors per type", "aspect": "1:1", }, "暴雪风": { "category": "游戏", "tags": "Blizzard stylized art, Overwatch / WoW concept style, exaggerated anatomy", "quality": "blizzard cinematic quality, heroic pose, strong silhouette", "neg": "photorealistic, anime chibi, flat", "camera": "heroic low angle, dynamic posing", "lighting": "dramatic three-point hero light", "palette": "rich saturated fantasy palette", "aspect": "3:2", }, # ========== 东方传统 Chinese/Japanese Traditional (v2.1 新增) ========== "敦煌壁画": { "category": "东方", "tags": "Dunhuang mural style, Tang dynasty fresco, flying apsara figures, silk road art", "quality": "weathered ancient mural texture, mineral pigment on plaster", "neg": "modern digital, anime, western", "camera": "flat mural frontal view", "lighting": "no modeling light, flat pigment", "palette": "mineral ochre, malachite green, azurite blue, gold leaf", "aspect": "4:3", }, "青花瓷": { "category": "东方", "tags": "Chinese blue and white porcelain motif, Ming dynasty pattern, cobalt underglaze", "quality": "porcelain surface detail, intricate floral motif", "neg": "full color, western, abstract", "camera": "", "lighting": "soft glazed porcelain highlight", "palette": "cobalt blue on pure white porcelain", "aspect": "1:1", }, "民国月份牌": { "category": "东方", "tags": "Republic of China calendar poster, 1920s Shanghai art deco fusion, qipao glamour", "quality": "vintage advertising print, lithograph texture", "neg": "modern digital, anime, photo", "camera": "", "lighting": "flat poster illumination", "palette": "faded pastel with gold gilt accents", "aspect": "2:3", }, "年画": { "category": "东方", "tags": "Chinese new year folk woodblock, auspicious symbols, chubby child figures", "quality": "traditional woodblock print texture, folk decorative", "neg": "photorealistic, minimalist, western", "camera": "", "lighting": "flat festive graphic", "palette": "festive vermillion, gold, pine green", "aspect": "3:4", }, "剪纸": { "category": "东方", "tags": "Chinese paper cutting art, red paper silhouette, intricate symmetric cutout", "quality": "fine paper cut detail, traditional folk craft", "neg": "full color, 3d, photorealistic", "camera": "", "lighting": "flat silhouette with background paper", "palette": "pure vermillion red on neutral background", "aspect": "1:1", }, "和风": { "category": "东方", "tags": "Japanese wafu aesthetic, traditional kimono elegance, wagashi sensibility", "quality": "refined Japanese traditional design", "neg": "western, modern pop, grunge", "camera": "", "lighting": "soft shoji-diffused light", "palette": "indigo, vermillion, sumi ink, cream washi", "aspect": "3:4", }, "汉服写真": { "category": "东方", "tags": "hanfu photography, Chinese traditional dress, oriental portrait", "quality": "ethereal hanfu fashion editorial, flowing silk", "neg": "western dress, modern clothing, cyberpunk", "camera": "85mm portrait, soft 3/4", "lighting": "diffuse morning light, soft bounce", "palette": "silk ink tones, jade, cream, plum", "aspect": "3:4", }, # ========== 动漫扩展 Anime extras (v2.1 新增) ========== "萌系": { "category": "动漫", "tags": "moe anime style, cute girl aesthetic, large sparkling eyes", "quality": "moekko illustration, clean lineart, rich anime shading", "neg": "gritty, adult, western comic", "camera": "", "lighting": "soft diffuse with catchlight in eyes", "palette": "pastel pink cream sky-blue", "aspect": "3:4", }, "厚涂": { "category": "动漫", "tags": "painterly anime, thick paint anime illustration, semi-realistic rendering", "quality": "artstation anime painting, detailed brushwork", "neg": "flat cel shading, vector, chibi", "camera": "", "lighting": "rembrandt on face, painterly shadows", "palette": "desaturated muted painterly tones", "aspect": "3:4", }, "轻小说封面": { "category": "动漫", "tags": "light novel cover illustration, Japanese LN art, glossy anime portrait", "quality": "bookshelf-ready cover composition, eye-catching character", "neg": "dark horror, western comic, 3d", "camera": "3/4 character hero, title-friendly negative space", "lighting": "cinematic anime key light", "palette": "vibrant anime palette with atmosphere", "aspect": "2:3", }, "赛璐璐": { "category": "动漫", "tags": "traditional cel-shaded anime, sharp shadow boundaries, limited anime palette", "quality": "classic 2d cel animation look, detailed line art", "neg": "painterly, 3d render, gradient shading", "camera": "", "lighting": "two-tone cel shading, hard shadow edges", "palette": "saturated flat anime palette", "aspect": "16:9", }, # ========== 现代设计 Modern Design (v2.1 新增) ========== "玻璃拟态": { "category": "设计", "tags": "glassmorphism, frosted glass UI, transparent blur layers, depth card stack", "quality": "modern UI glass effect, realistic refraction, clean layout", "neg": "flat 2d, skeuomorphic wood, pixel art", "camera": "", "lighting": "subtle inner glow, soft backlight through glass", "palette": "pastel gradient backdrop with translucent glass", "aspect": "3:4", }, "新拟态": { "category": "设计", "tags": "neumorphism, soft UI, extruded plastic button, subtle dual shadow", "quality": "modern minimal UI, monochrome neumorphic elements", "neg": "flat, photorealistic, grunge", "camera": "", "lighting": "soft dual light and dark shadow", "palette": "monochrome beige or gray single-tone", "aspect": "1:1", }, "孟菲斯": { "category": "设计", "tags": "Memphis design, 1980s postmodern, geometric shapes, squiggle pattern, bold primaries", "quality": "playful postmodern graphic, bold composition", "neg": "minimalist, photorealistic, classical", "camera": "", "lighting": "flat graphic, no modeling", "palette": "hot pink, cyan, yellow, black squiggle pattern", "aspect": "1:1", }, "杂志编排": { "category": "设计", "tags": "editorial magazine layout, bold serif typography, grid-based design", "quality": "international typographic style, vogue spread quality", "neg": "amateur, overcluttered, cute", "camera": "", "lighting": "clean flat studio-style", "palette": "monochrome with single bold accent", "aspect": "3:4", }, "包豪斯": { "category": "设计", "tags": "Bauhaus design, de stijl geometric, primary color blocks, constructivist", "quality": "1920s modernist design school, pure geometry", "neg": "ornate, victorian, realistic", "camera": "", "lighting": "flat geometric", "palette": "primary red yellow blue + black on white", "aspect": "1:1", }, "奶油风": { "category": "设计", "tags": "cream style, soft beige palette, warm minimal aesthetic, korean lifestyle", "quality": "instagram lifestyle aesthetic, soft velvety texture", "neg": "dark, saturated, edgy", "camera": "", "lighting": "natural soft window light", "palette": "cream, soft beige, butter yellow, milk tea", "aspect": "4:5", }, # ========== 建筑 & 氛围扩展 (v2.1 新增) ========== "粗野主义": { "category": "场景", "tags": "brutalist architecture, raw concrete, heavy geometric mass, béton brut", "quality": "mid-century brutalist landmark, imposing scale", "neg": "ornate, baroque, flimsy", "camera": "wide low-angle heroic architecture shot", "lighting": "harsh sun shadow across concrete", "palette": "raw concrete gray with sky contrast", "aspect": "16:9", }, "北欧极简": { "category": "场景", "tags": "scandinavian interior, nordic minimalism, light wood, warm neutral", "quality": "hygge lifestyle, interior magazine quality", "neg": "ornate, cluttered, dark gothic", "camera": "wide 24mm interior architectural", "lighting": "large window natural light", "palette": "warm wood, white wall, soft gray", "aspect": "16:9", }, "侘寂": { "category": "场景", "tags": "wabi-sabi aesthetic, imperfect natural beauty, weathered texture, zen japanese", "quality": "quiet imperfection, aged material detail", "neg": "glossy modern, bright colors, ornate", "camera": "", "lighting": "soft diffused natural, muted", "palette": "muted earth, weathered gray, aged beige", "aspect": "4:5", }, # ========== 摄影扩展 (v2.1 新增) ========== "暗黑美食": { "category": "摄影", "tags": "dark food photography, moody cuisine, chiaroscuro plating", "quality": "michelin-level dark food styling, dramatic shadow", "neg": "bright cheerful, flat, cluttered", "camera": "100mm macro 45-degree, side low-key", "lighting": "single hard key from behind, deep shadow", "palette": "deep black with food color accent", "aspect": "4:5", }, "日杂": { "category": "摄影", "tags": "Japanese lifestyle magazine, natural light still life, clean minimalism", "quality": "muji aesthetic, calm everyday beauty", "neg": "dark moody, dramatic, saturated", "camera": "50mm still life, slight top-down", "lighting": "soft window daylight, no drama", "palette": "cream, light wood, pale pastel", "aspect": "4:5", }, "街头潮流": { "category": "摄影", "tags": "streetwear fashion, urban hypebeast, sneaker culture", "quality": "street style magazine editorial, confident pose", "neg": "formal suit, fantasy, kawaii", "camera": "35mm full body street fashion", "lighting": "harsh urban daylight or neon", "palette": "high contrast monochrome + brand accent", "aspect": "3:4", }, # ========== 综合 (v2.1 新增) ========== "疗愈治愈": { "category": "场景", "tags": "healing cozy aesthetic, soft warm interior, cat sunlight, tea steam", "quality": "soothing slow-life scene", "neg": "dramatic action, dark, cyberpunk", "camera": "", "lighting": "warm golden hour through window", "palette": "warm honey, cream, dusty pink", "aspect": "4:5", }, "美式复古": { "category": "场景", "tags": "americana retro, 1950s diner, vintage coca-cola americana", "quality": "Norman Rockwell meets mid-century ad", "neg": "asian, modern sleek, futuristic", "camera": "", "lighting": "warm diner fluorescent or golden", "palette": "cherry red, cream, turquoise", "aspect": "3:2", }, } # ───────────────────────────────────────────────────────── # 别名 (英文 / 同义词 → 规范预设名) # ───────────────────────────────────────────────────────── ALIASES: Dict[str, str] = { # 英文 "realistic": "写实摄影", "photo": "写实摄影", "photography": "写实摄影", "film": "胶片摄影", "analog": "胶片摄影", "bw": "黑白摄影", "blackwhite": "黑白摄影", "monochrome": "黑白摄影", "portrait": "人像摄影", "fashion": "时尚大片", "editorial": "时尚大片", "food": "美食摄影", "product": "产品摄影", "ecommerce": "产品摄影", "macro": "微距摄影", "aerial": "航拍摄影", "drone": "航拍摄影", "street": "街拍纪实", "documentary": "街拍纪实", "anime": "动漫", "ghibli": "宫崎骏", "miyazaki": "宫崎骏", "shinkai": "新海诚", "makoto": "新海诚", "comic": "美漫", "marvel": "美漫", "chibi": "Q版", "kawaii": "Q版", "storybook": "童话绘本", "childrensbook": "童话绘本", "watercolor": "水彩", "oil": "油画", "ink": "水墨", "sumi": "水墨", "gongbi": "工笔国画", "ukiyoe": "浮世绘", "lineart": "线稿", "pixel": "像素艺术", "3d": "3DC4D", "c4d": "3DC4D", "octane": "3DC4D", "blindbox": "盲盒手办", "popmart": "盲盒手办", "lowpoly": "低多边形", "isometric": "等距视图", "iso": "等距视图", "claymation": "粘土", "felt": "毛毡手工", "papercraft": "纸艺", "minimal": "极简主义", "minimalist": "极简主义", "flat": "平面设计", "vector": "平面设计", "logo": "Logo设计", "icon": "图标设计", "infographic": "信息图", "kv": "品牌KV", "album": "专辑封面", "poster": "复古海报", "movieposter": "电影海报", "sticker": "表情包", "emoji": "表情包", "impressionist": "印象派", "vangogh": "后印象派", "postimpressionist": "后印象派", "artnouveau": "新艺术", "mucha": "新艺术", "artdeco": "装饰艺术", "cyberpunk": "赛博朋克", "steampunk": "蒸汽朋克", "scifi": "科幻", "fantasy": "奇幻", "darkfantasy": "黑暗奇幻", "grimdark": "黑暗奇幻", "guochao": "国潮", "y2k": "Y2K", "vaporwave": "Vaporwave", "synthwave": "Vaporwave", "neon": "霓虹灯牌", "archviz": "建筑可视化", "architecture": "建筑可视化", "cinematic": "电影感", "cinema": "电影感", "concept": "概念艺术", "conceptart": "概念艺术", # v2.1 游戏 "genshin": "原神", "mihoyo": "原神", "honkai": "崩铁星穹", "starrail": "崩铁星穹", "lol": "英雄联盟", "leagueoflegends": "英雄联盟", "diablo": "暗黑4", "valorant": "Valorant", "pokemon": "Pokemon", "blizzard": "暴雪风", "overwatch": "暴雪风", "wow": "暴雪风", # v2.1 东方 "dunhuang": "敦煌壁画", "qinghua": "青花瓷", "porcelain": "青花瓷", "yuefenpai": "民国月份牌", "wafu": "和风", "hanfu": "汉服写真", "papercut": "剪纸", "nianhua": "年画", # v2.1 动漫扩展 "moe": "萌系", "painterlyanime": "厚涂", "lightnovel": "轻小说封面", "lncover": "轻小说封面", "cellshaded": "赛璐璐", "celshaded": "赛璐璐", # v2.1 设计 "glassmorphism": "玻璃拟态", "glass": "玻璃拟态", "neumorphism": "新拟态", "memphis": "孟菲斯", "editorial": "杂志编排", "bauhaus": "包豪斯", "cream": "奶油风", "korean": "奶油风", # v2.1 建筑 / 氛围 "brutalism": "粗野主义", "brutalist": "粗野主义", "nordic": "北欧极简", "scandinavian": "北欧极简", "wabisabi": "侘寂", "zen": "侘寂", # v2.1 摄影 "darkfood": "暗黑美食", "muji": "日杂", "streetwear": "街头潮流", "hypebeast": "街头潮流", # v2.1 综合 "healing": "疗愈治愈", "cozy": "疗愈治愈", "americana": "美式复古", } # ───────────────────────────────────────────────────────── # 意图关键词 → (推荐预设, 推荐画幅) # ───────────────────────────────────────────────────────── INTENT_KEYWORDS: List[Tuple[str, str, str]] = [ # (关键词, 推荐预设, 推荐画幅) ("logo", "Logo设计", "1:1"), ("徽标", "Logo设计", "1:1"), ("标志", "Logo设计", "1:1"), ("icon", "图标设计", "1:1"), ("图标", "图标设计", "1:1"), ("app图标", "图标设计", "1:1"), ("电影海报", "电影海报", "2:3"), ("海报", "复古海报", "3:4"), ("poster", "复古海报", "3:4"), ("封面", "专辑封面", "1:1"), ("专辑", "专辑封面", "1:1"), ("表情包", "表情包", "1:1"), ("贴纸", "表情包", "1:1"), ("信息图", "信息图", "3:4"), ("infographic", "信息图", "3:4"), ("kv", "品牌KV", "16:9"), ("主视觉", "品牌KV", "16:9"), ("产品", "产品摄影", "1:1"), ("电商", "产品摄影", "1:1"), ("商品", "产品摄影", "1:1"), ("美食", "美食摄影", "1:1"), ("食物", "美食摄影", "1:1"), ("菜品", "美食摄影", "1:1"), ("头像", "人像摄影", "1:1"), ("肖像", "人像摄影", "3:4"), ("人像", "人像摄影", "3:4"), ("时装", "时尚大片", "3:4"), ("时尚", "时尚大片", "3:4"), ("街拍", "街拍纪实", "3:2"), ("纪实", "街拍纪实", "3:2"), ("风景", "写实摄影", "16:9"), ("风光", "写实摄影", "16:9"), ("建筑", "建筑可视化", "16:9"), ("室内", "建筑可视化", "4:3"), ("手办", "盲盒手办", "1:1"), ("盲盒", "盲盒手办", "1:1"), ("玩具", "盲盒手办", "1:1"), ("航拍", "航拍摄影", "16:9"), ("鸟瞰", "航拍摄影", "16:9"), ("微距", "微距摄影", "1:1"), ("赛博", "赛博朋克", "21:9"), ("cyberpunk", "赛博朋克", "21:9"), ("蒸汽朋克", "蒸汽朋克", "3:2"), ("科幻", "科幻", "21:9"), ("未来", "科幻", "21:9"), ("奇幻", "奇幻", "16:9"), ("魔幻", "奇幻", "16:9"), ("黑暗", "黑暗奇幻", "2:3"), ("水墨", "水墨", "3:4"), ("国画", "工笔国画", "3:4"), ("工笔", "工笔国画", "3:4"), ("浮世绘", "浮世绘", "2:3"), ("童话", "童话绘本", "4:3"), ("绘本", "童话绘本", "4:3"), ("宫崎骏", "宫崎骏", "16:9"), ("新海诚", "新海诚", "16:9"), ("动漫", "动漫", "3:4"), ("二次元", "动漫", "3:4"), ("q版", "Q版", "1:1"), ("Q版", "Q版", "1:1"), ("chibi", "Q版", "1:1"), ("线稿", "线稿", "1:1"), ("像素", "像素艺术", "1:1"), ("3d", "3DC4D", "1:1"), ("c4d", "3DC4D", "1:1"), ("粘土", "粘土", "1:1"), ("等距", "等距视图", "1:1"), ("国潮", "国潮", "3:4"), ("霓虹", "霓虹灯牌", "3:2"), ("电影", "电影感", "21:9"), ("cinema", "电影感", "21:9"), ("concept", "概念艺术", "21:9"), ("概念图", "概念艺术", "21:9"), ("复古", "复古海报", "3:4"), ("vintage", "复古海报", "3:4"), # v2.1 游戏 ("原神", "原神", "3:4"), ("genshin", "原神", "3:4"), ("崩铁", "崩铁星穹", "3:4"), ("星穹", "崩铁星穹", "3:4"), ("lol", "英雄联盟", "16:9"), ("英雄联盟", "英雄联盟", "16:9"), ("valorant", "Valorant", "3:4"), ("暗黑4", "暗黑4", "3:2"), ("diablo", "暗黑4", "3:2"), ("pokemon", "Pokemon", "1:1"), ("宝可梦", "Pokemon", "1:1"), ("暴雪", "暴雪风", "3:2"), ("overwatch", "暴雪风", "3:2"), # v2.1 东方 ("敦煌", "敦煌壁画", "4:3"), ("壁画", "敦煌壁画", "4:3"), ("青花瓷", "青花瓷", "1:1"), ("月份牌", "民国月份牌", "2:3"), ("民国", "民国月份牌", "2:3"), ("剪纸", "剪纸", "1:1"), ("年画", "年画", "3:4"), ("汉服", "汉服写真", "3:4"), ("和风", "和风", "3:4"), ("日系", "日杂", "4:5"), ("日杂", "日杂", "4:5"), # v2.1 动漫扩展 ("萌", "萌系", "3:4"), ("萌系", "萌系", "3:4"), ("厚涂", "厚涂", "3:4"), ("轻小说", "轻小说封面", "2:3"), ("赛璐璐", "赛璐璐", "16:9"), # v2.1 现代设计 ("玻璃拟态", "玻璃拟态", "3:4"), ("glassmorphism", "玻璃拟态", "3:4"), ("新拟态", "新拟态", "1:1"), ("neumorphism", "新拟态", "1:1"), ("孟菲斯", "孟菲斯", "1:1"), ("memphis", "孟菲斯", "1:1"), ("杂志", "杂志编排", "3:4"), ("magazine", "杂志编排", "3:4"), ("包豪斯", "包豪斯", "1:1"), ("bauhaus", "包豪斯", "1:1"), ("奶油", "奶油风", "4:5"), ("ins风", "奶油风", "4:5"), ("韩系", "奶油风", "4:5"), # v2.1 建筑 / 氛围 ("粗野", "粗野主义", "16:9"), ("brutalism", "粗野主义", "16:9"), ("北欧", "北欧极简", "16:9"), ("scandinavian", "北欧极简", "16:9"), ("侘寂", "侘寂", "4:5"), ("wabi", "侘寂", "4:5"), ("禅意", "侘寂", "4:5"), # v2.1 摄影 ("暗黑美食", "暗黑美食", "4:5"), ("darkfood", "暗黑美食", "4:5"), ("街头", "街头潮流", "3:4"), ("潮牌", "街头潮流", "3:4"), ("streetwear", "街头潮流", "3:4"), # v2.1 综合 ("治愈", "疗愈治愈", "4:5"), ("疗愈", "疗愈治愈", "4:5"), ("cozy", "疗愈治愈", "4:5"), ("美式复古", "美式复古", "3:2"), ("americana", "美式复古", "3:2"), ] # ───────────────────────────────────────────────────────── # 构图关键词 # ───────────────────────────────────────────────────────── COMPOSITION_KEYWORDS: Dict[str, str] = { "特写": "extreme close-up shot", "近景": "close-up shot", "中景": "medium shot", "全身": "full body shot", "半身": "medium shot, waist up", "远景": "wide shot, establishing shot", "全景": "panoramic view", "俯拍": "top-down view", "俯视": "top-down view", "仰拍": "low angle shot, looking up", "仰视": "low angle shot, looking up", "鸟瞰": "bird's eye view, aerial", "平视": "eye-level shot", "正面": "front view", "侧面": "side profile view", "背面": "back view", "三分之二": "three-quarter view", } # ───────────────────────────────────────────────────────── # 情绪关键词 # ───────────────────────────────────────────────────────── MOOD_KEYWORDS: Dict[str, str] = { "温暖": "warm cozy atmosphere, golden tones", "温馨": "warm cozy atmosphere, golden tones", "冷峻": "cold atmosphere, steely blue tones", "神秘": "mysterious mood, foggy, dim lighting", "梦幻": "dreamy ethereal mood, soft glow, bokeh", "欢快": "joyful vibrant, bright cheerful colors", "忧郁": "melancholic mood, muted cool palette", "压抑": "oppressive mood, deep shadows, heavy atmosphere", "史诗": "epic grandeur, cinematic scale", "高级": "luxury sophistication, premium materials", "治愈": "healing soft ambiance, soothing", "清新": "fresh airy light pastel", "紧张": "tense suspense mood, high contrast", "浪漫": "romantic soft pink glow", } # ───────────────────────────────────────────────────────── # 时间 / 天气 / 季节关键词（v2.1 新增） # ───────────────────────────────────────────────────────── TIME_KEYWORDS: Dict[str, str] = { "清晨": "early morning, dawn, soft first light", "早晨": "morning light, fresh daylight", "上午": "bright morning sunshine", "正午": "high noon, overhead sun", "下午": "afternoon light, long soft shadows", "黄昏": "dusk, golden hour, magic hour", "傍晚": "dusk, golden hour, magic hour", "日落": "sunset, golden hour", "夜晚": "night time, dark ambient", "深夜": "late night, moonlit, dim", "午夜": "midnight, dark sky", "黎明": "dawn, blue hour breaking", "蓝调时刻": "blue hour, twilight gradient sky", "魔法时刻": "magic hour, warm golden glow", } WEATHER_KEYWORDS: Dict[str, str] = { "晴天": "sunny clear sky", "多云": "cloudy overcast sky", "阴天": "overcast gray sky", "下雨": "raining, wet reflective surfaces", "雨天": "rainy weather, soft rain", "大雨": "heavy rain, downpour, water droplets", "暴雨": "stormy rain, dramatic weather", "下雪": "snowing, snowflakes in air", "雪天": "snowy landscape, white blanket", "暴雪": "blizzard, heavy snow storm", "雾天": "foggy misty atmosphere", "有雾": "foggy misty atmosphere", "晨雾": "morning mist, dreamy fog", "风暴": "stormy weather, dramatic clouds", "雷雨": "thunderstorm, lightning in sky", } SEASON_KEYWORDS: Dict[str, str] = { "春天": "spring season, cherry blossoms, fresh green", "春季": "spring season, cherry blossoms, fresh green", "夏天": "summer season, lush greenery, warm sun", "夏季": "summer season, lush greenery, warm sun", "秋天": "autumn season, golden foliage, maple leaves", "秋季": "autumn season, golden foliage, maple leaves", "冬天": "winter season, snow, bare branches", "冬季": "winter season, snow, bare branches", "樱花季": "cherry blossom season, sakura petals falling", "枫叶季": "maple season, red foliage", } # ───────────────────────────────────────────────────────── # 质量档位（v2.1 新增） # ───────────────────────────────────────────────────────── QUALITY_TIERS: Dict[str, str] = { "basic": "high quality, detailed", "pro": "masterpiece, best quality, ultra detailed, 8k", "master": "masterpiece, best quality, ultra detailed, 8k, hdr, " "intricate details, sharp focus, award winning, trending on artstation, " "professional, highly polished", } # ───────────────────────────────────────────────────────── # 负向需求识别（v2.1 新增） # 匹配 "不要X" / "no X" / "avoid X" / "without X" / "没有X" / "避免X" # ───────────────────────────────────────────────────────── NEGATIVE_PATTERNS = [ re.compile(r"不要([^,，。.;；]{1,20})"), re.compile(r"没有([^,，。.;；]{1,20})"), re.compile(r"避免([^,，。.;；]{1,20})"), re.compile(r"\bno\s+([a-zA-Z\s]{1,30})(?=[,.]|\s*$)"), re.compile(r"\bavoid\s+([a-zA-Z\s]{1,30})(?=[,.]|\s*$)"), re.compile(r"\bwithout\s+([a-zA-Z\s]{1,30})(?=[,.]|\s*$)"), ] # ───────────────────────────────────────────────────────── # 画幅 → 模型特定写法 # ───────────────────────────────────────────────────────── ASPECT_TO_MJ = { "1:1": "--ar 1:1", "3:4": "--ar 3:4", "4:3": "--ar 4:3", "3:2": "--ar 3:2", "2:3": "--ar 2:3", "16:9": "--ar 16:9", "9:16": "--ar 9:16", "21:9": "--ar 21:9", "4:5": "--ar 4:5", } ASPECT_TO_SDXL = { "1:1": "1024x1024", "3:4": "896x1152", "4:3": "1152x896", "3:2": "1216x832", "2:3": "832x1216", "16:9": "1344x768", "9:16": "768x1344", "21:9": "1536x640", "4:5": "912x1144", } # ───────────────────────────────────────────────────────── # 工具函数 # ───────────────────────────────────────────────────────── def resolve_preset(name: Optional[str]) -> str: """预设名归一化：支持中文 / 英文别名 / 大小写不敏感。 v3.0: `@` 前缀加载 learned preset（来自 style_learn.py）。 learned preset 会被即时注册到 STYLE_PRESETS（运行期，不污染源文件）。 """ if not name: return "" name_str = name.strip() # v3.0: @ 前缀 = learned preset if name_str.startswith("@"): learned_name = name_str[1:] if learned_name in STYLE_PRESETS: return learned_name # 已经注册过了 try: from style_learn import learned_load lp = learned_load(learned_name) except Exception: lp = None if lp: # 把 learned preset 注册进 STYLE_PRESETS（仅当前进程，不持久化） STYLE_PRESETS[learned_name] = { "category": lp.get("category", "学习"), "tags": lp.get("tags", ""), "quality": lp.get("quality", "high quality, detailed"), "neg": lp.get("neg", "low quality"), "camera": lp.get("camera", ""), "lighting": lp.get("lighting", ""), "palette": lp.get("palette", ""), "aspect": lp.get("aspect", "1:1"), } return learned_name return "" key = name_str.lower().replace(" ", "").replace("-", "").replace("_", "") if key in ALIASES: return ALIASES[key] for p in STYLE_PRESETS: if p.lower() == key or p.lower().replace(" ", "") == key: return p return name_str if name_str in STYLE_PRESETS else "" def parse_requirement(text: str) -> Dict[str, str]: """从用户输入中解析意图、画幅、构图、情绪、时间、天气、季节、负向需求。返回 dict 字段： preset_suggestion 推荐预设（可能为空） aspect_suggestion 推荐画幅 composition 构图片段（英文，可为空） mood 情绪片段（英文，可为空） time_of_day 时间片段（英文，可为空） weather 天气片段（英文，可为空） season 季节片段（英文，可为空） user_negatives 用户抽出的负向关键词（原文，英/中） """ lower = text.lower() out = { "preset_suggestion": "", "aspect_suggestion": "", "composition": "", "mood": "", "time_of_day": "", "weather": "", "season": "", "user_negatives": [], } for kw, preset, aspect in INTENT_KEYWORDS: if kw.lower() in lower: out["preset_suggestion"] = preset out["aspect_suggestion"] = aspect break for zh, en in COMPOSITION_KEYWORDS.items(): if zh in text: out["composition"] = en break for zh, en in MOOD_KEYWORDS.items(): if zh in text: out["mood"] = en break for zh, en in TIME_KEYWORDS.items(): if zh in text: out["time_of_day"] = en break for zh, en in WEATHER_KEYWORDS.items(): if zh in text: out["weather"] = en break for zh, en in SEASON_KEYWORDS.items(): if zh in text: out["season"] = en break # 负向需求抽取 negs: List[str] = [] for pat in NEGATIVE_PATTERNS: for m in pat.finditer(text): token = m.group(1).strip().rstrip(",.，；;") if token and token not in negs: negs.append(token) out["user_negatives"] = negs return out def strip_negative_clauses(text: str) -> str: """从主体描述中去除 "不要X" 类子句，只保留正向描述。""" cleaned = text for pat in NEGATIVE_PATTERNS: cleaned = pat.sub("", cleaned) # 清理多余标点和空白 cleaned = re.sub(r"\s*,\s*,+", ", ", cleaned) cleaned = re.sub(r"\s+", " ", cleaned).strip(" ,，。.;；") return cleaned def sanitize_subject(text: str) -> str: """清理主体描述：去除首尾标点和多余空白。""" return re.sub(r"\s+", " ", text).strip().rstrip(".,，、。;；") def stable_seed(subject: str, preset: str) -> int: """根据主体 + 预设生成稳定的种子建议（32-bit 正整数）。""" h = hashlib.md5(f"{subject}|{preset}".encode("utf-8")).hexdigest() return int(h[:8], 16) def parse_mix_preset(preset_arg: str) -> Tuple[str, Optional[str]]: """支持 `-p A+B` 语法。返回 (primary, secondary or None)。""" if not preset_arg: return "", None if "+" not in preset_arg: return preset_arg, None parts = [p.strip() for p in preset_arg.split("+", 1)] if len(parts) != 2 or not parts[0] or not parts[1]: return preset_arg, None return parts[0], parts[1] def mix_presets(primary: str, secondary: str, ratio: float = 0.6, model: str = "通用") -> Dict[str, str]: """加权融合两个预设，主预设 ratio，副预设 1-ratio。融合策略： tags 按权重前置主预设标签，SD 模式额外加 (tag:weight) 语法 quality 主预设主导 neg 合并去重 camera 主预设（主导镜头语言） lighting 主预设主导，副预设为辅 palette 混合两者（主在前） aspect 主预设 category mix """ p1 = STYLE_PRESETS[primary] p2 = STYLE_PRESETS[secondary] ratio = max(0.1, min(0.9, ratio)) primary_tags = [t.strip() for t in p1["tags"].split(",") if t.strip()] secondary_tags = [t.strip() for t in p2["tags"].split(",") if t.strip()] is_sd = model in ("Stable Diffusion", "SD", "sd", "SDXL", "sdxl") if is_sd: w1 = round(0.8 + ratio * 0.6, 2) w2 = round(0.8 + (1 - ratio) * 0.6, 2) merged_tags = [f"({t}:{w1})" for t in primary_tags] + [f"({t}:{w2})" for t in secondary_tags] else: n1 = max(1, int(round(len(primary_tags) * (0.5 + ratio)))) n2 = max(1, int(round(len(secondary_tags) * (0.5 + (1 - ratio))))) merged_tags = primary_tags[:n1] + secondary_tags[:n2] merged_palette = ", ".join([ x for x in [p1.get("palette", ""), p2.get("palette", "")] if x ]) if p1.get("lighting") and p2.get("lighting"): merged_lighting = f"{p1['lighting']}, blended with {p2['lighting']}" else: merged_lighting = p1.get("lighting") or p2.get("lighting", "") neg_tokens = [] seen = set() for src in (p1["neg"], p2["neg"]): for t in src.split(","): t = t.strip() if t and t.lower() not in seen: seen.add(t.lower()) neg_tokens.append(t) return { "category": f"{p1['category']}+{p2['category']}", "tags": ", ".join(merged_tags), "quality": p1["quality"], "neg": ", ".join(neg_tokens), "camera": p1.get("camera", "") or p2.get("camera", ""), "lighting": merged_lighting, "palette": merged_palette, "aspect": p1.get("aspect", "1:1"), } def build_prompt( subject: str, preset: str, model: str = "通用", aspect: str = "", extra_mood: str = "", extra_composition: str = "", extra_negatives: str = "", seed: Optional[int] = None, quality_tier: str = "pro", character_sheet: bool = False, mix_secondary: Optional[str] = None, mix_ratio: float = 0.6, ) -> Dict: """构建增强后的提示词。 v2.1 新增参数： extra_negatives 额外负面词，逗号分隔 quality_tier 质量档位 basic / pro / master character_sheet 角色设定图模式（T-pose 多视图） v2.2 新增参数： mix_secondary 副预设名（已 resolve），与主预设融合 mix_ratio 主预设权重 0.1-0.9 """ preset = resolve_preset(preset) or "写实摄影" if mix_secondary: mix_secondary = resolve_preset(mix_secondary) or "" if mix_secondary and mix_secondary != preset: data = mix_presets(preset, mix_secondary, mix_ratio, model) mixed_label = f"{preset}+{mix_secondary}@{mix_ratio:.2f}" else: data = STYLE_PRESETS[preset] mixed_label = "" auto = parse_requirement(subject) subject_clean = sanitize_subject(strip_negative_clauses(subject)) if not extra_composition: extra_composition = auto["composition"] if not extra_mood: extra_mood = auto["mood"] if not aspect: aspect = data.get("aspect", "1:1") # 时间 / 天气 / 季节 ambient_parts = [auto["time_of_day"], auto["weather"], auto["season"]] ambient = ", ".join([x for x in ambient_parts if x]) # 角色设定图模式 if character_sheet: subject_clean = ( f"character design sheet of {subject_clean}, " f"multiple views: front view, three-quarter view, side view, back view, " f"T-pose, clean white background, reference sheet, " f"consistent character design" ) aspect = "16:9" consistency_parts = [ data["tags"], data.get("camera", ""), data.get("lighting", ""), data.get("palette", ""), ] consistency = ", ".join([x for x in consistency_parts if x]) # 质量档位（替换 UNIVERSAL_QUALITY） tier_quality = QUALITY_TIERS.get(quality_tier, QUALITY_TIERS["pro"]) quality_combined = f"{data['quality']}, {tier_quality}" # 负面词：预设 + 全局过滤 + 用户抽出 + 显式追加 neg_exclude = list(PRESET_NEG_EXCLUDE.get(preset, [])) if mix_secondary and mix_secondary in PRESET_NEG_EXCLUDE: neg_exclude.extend(PRESET_NEG_EXCLUDE[mix_secondary]) universal_neg_filtered = _filter_neg(UNIVERSAL_NEG, neg_exclude) user_neg_from_subject = ", ".join(auto["user_negatives"]) neg_parts = [data["neg"], universal_neg_filtered, user_neg_from_subject, extra_negatives] neg_combined = ", ".join([x for x in neg_parts if x]) extras = ", ".join([x for x in [extra_composition, extra_mood, ambient] if x]) seed_key = mixed_label or preset # 按模型生成不同形式 if model in ("Midjourney", "MJ", "mj"): core = f"{subject_clean}, {consistency}" if extras: core = f"{core}, {extras}" core = f"{core}, {quality_combined}" flags = [ASPECT_TO_MJ.get(aspect, "--ar 1:1"), "--stylize 250"] positive = f"{core} {' '.join(flags)}" negative = f"--no {neg_combined}" hint = ( "Midjourney tips：\n" " • 角色/产品系列一致：加 --cref 或 --sref \n" f" • 想要更风格化加 --stylize 500~750；更写实降到 --stylize 50\n" f" • 建议 seed 锁定：--seed {seed or stable_seed(subject_clean, seed_key)}" ) elif model in ("Stable Diffusion", "SD", "sd"): positive = ( f"({subject_clean}:1.2), {consistency}" + (f", {extras}" if extras else "") + f", {quality_combined}" ) negative = neg_combined hint = ( "Stable Diffusion tips：\n" f" • 强化权重: (word:1.2~1.5), 减弱: [word:0.7]\n" f" • 建议尺寸 (SD 1.5): 512x{{hw_from_aspect}}; (SDXL): {ASPECT_TO_SDXL.get(aspect,'1024x1024')}\n" f" • 采样: DPM++ 2M Karras, 30 steps, CFG 6.5\n" f" • 建议 seed 锁定: {seed or stable_seed(subject_clean, seed_key)}（系列同 seed 提升一致性）" ) elif model in ("SDXL", "sdxl"): positive = ( f"{subject_clean}, {consistency}" + (f", {extras}" if extras else "") + f", {quality_combined}" ) negative = neg_combined hint = ( "SDXL tips：\n" f" • 推荐尺寸: {ASPECT_TO_SDXL.get(aspect,'1024x1024')}\n" f" • 采样: DPM++ SDE Karras, 25-30 steps, CFG 5-7\n" f" • Refiner 使用率 0.2-0.3\n" f" • seed: {seed or stable_seed(subject_clean, seed_key)}" ) elif model in ("DALL-E", "DALL·E", "dalle", "DALLE"): parts = [f"A {preset} style image of {subject_clean}"] if data.get("camera"): parts.append(f"captured with {data['camera']}") if data.get("lighting"): parts.append(f"lit by {data['lighting']}") if data.get("palette"): parts.append(f"with a color palette of {data['palette']}") if extras: parts.append(extras) parts.append("highly detailed, professional composition") positive = ". ".join(parts) + "." negative = "(DALL-E 3 忽略负面提示，已通过正向描述规避)" hint = ( "DALL-E 3 tips：\n" " • 用自然语言句子 + 细节形容词效果最佳\n" f" • 画幅: {aspect} (仅支持 1:1, 16:9, 9:16 在 ChatGPT 内)\n" " • 一致性: 在同一会话连续生成并引用 \"use the same character\"" ) elif model in ("Flux", "flux"): positive = ( f"{subject_clean}. {consistency}." + (f" {extras}." if extras else "") + f" {quality_combined}." ) negative = neg_combined hint = ( "Flux tips：\n" " • 支持长自然语言提示，可加句式结构 \"The subject is...\"\n" f" • 建议 Flux Dev: guidance 3.5; Flux Schnell: guidance 0\n" f" • seed: {seed or stable_seed(subject_clean, seed_key)}" ) else: # 通用 positive = ( f"{subject_clean}, {consistency}" + (f", {extras}" if extras else "") + f", {quality_combined}" ) negative = neg_combined hint = "通用格式：Midjourney / SD / Flux 皆可直接使用。" return { "version": VERSION, "original": subject, "preset": preset, "mix_secondary": mix_secondary or "", "mix_ratio": mix_ratio if mix_secondary else None, "mix_label": mixed_label, "model": model, "aspect": aspect, "composition": extra_composition, "mood": extra_mood, "time_of_day": auto.get("time_of_day", ""), "weather": auto.get("weather", ""), "season": auto.get("season", ""), "quality_tier": quality_tier, "character_sheet": character_sheet, "user_negatives": auto.get("user_negatives", []), "seed_suggestion": seed or stable_seed(subject_clean, seed_key), "positive": positive, "negative": negative, "hint": hint, "consistency_lock": { "camera": data.get("camera", ""), "lighting": data.get("lighting", ""), "palette": data.get("palette", ""), "aspect": aspect, }, } def build_series( subject: str, preset: str, model: str, aspect: str, variations: List[str], seed: Optional[int] = None, quality_tier: str = "pro", mix_secondary: Optional[str] = None, mix_ratio: float = 0.6, ) -> List[Dict]: """系列批量生成：共享 camera/lighting/palette/seed 锁，仅替换主体描述。""" if seed is None: seed_key = f"{preset}+{mix_secondary}@{mix_ratio:.2f}" if mix_secondary else preset seed = stable_seed(subject, seed_key) results = [] for i, v in enumerate(variations, 1): full = f"{subject}, {v}" if v and v != subject else subject r = build_prompt( full, preset, model, aspect, seed=seed, quality_tier=quality_tier, mix_secondary=mix_secondary, mix_ratio=mix_ratio, ) r["series_index"] = i r["series_total"] = len(variations) results.append(r) return results # ───────────────────────────────────────────────────────── # 输出 # ───────────────────────────────────────────────────────── def print_prompt(result: Dict): sep = "═" * 60 print(f"\n{sep}") if "series_index" in result: print(f"📸 系列生成 [{result['series_index']}/{result['series_total']}]") if result.get("character_sheet"): print("👤 角色设定图模式：T-pose 多视图（喂给 MJ --cref / IP-Adapter）") print(f"📌 原始描述 : {result['original']}") if result.get("mix_label"): print(f"🎨 风格预设 : {result['mix_label']} (混合)") else: print(f"🎨 风格预设 : {result['preset']}") print(f"🤖 目标模型 : {result['model']}") print(f"📐 画幅 : {result['aspect']}") print(f"⭐ 质量档位 : {result.get('quality_tier', 'pro')}") if result.get("composition"): print(f"🎥 构图 : {result['composition']}") if result.get("mood"): print(f"🎭 情绪 : {result['mood']}") if result.get("time_of_day"): print(f"🕐 时间 : {result['time_of_day']}") if result.get("weather"): print(f"☁️ 天气 : {result['weather']}") if result.get("season"): print(f"🍂 季节 : {result['season']}") if result.get("user_negatives"): print(f"🚫 用户负向 : {', '.join(result['user_negatives'])} → 已入负面") print(f"🎲 种子建议 : {result['seed_suggestion']}") print(f"\n✅ 正向提示词：") print(f"{result['positive']}") print(f"\n❌ 负向提示词：") print(f"{result['negative']}") print(f"\n🔒 一致性锁：") for k, v in result["consistency_lock"].items(): if v: print(f" {k:8s}: {v}") print(f"\n💡 {result['hint']}") print(f"{sep}\n") def list_presets(with_examples: bool = False): by_cat: Dict[str, List[str]] = {} for name, data in STYLE_PRESETS.items(): by_cat.setdefault(data["category"], []).append(name) print(f"\n🎨 可用风格预设 (共 {len(STYLE_PRESETS)} 款)") print("─" * 50) order = ["摄影", "动漫", "插画", "3D", "设计", "艺术", "场景", "游戏", "东方"] for cat in order: if cat not in by_cat: continue print(f"\n【{cat}】 {len(by_cat[cat])} 款") for name in by_cat[cat]: if with_examples: urls = preset_example_urls(name) print(f" • {name}") print(f" 🔍 Lexica: {urls['lexica']}") print(f" 🔍 Civitai: {urls['civitai']}") else: print(f" • {name}") print( "\n💡 同义别名示例：anime, ghibli, cyberpunk, genshin, lol, " "dunhuang, hanfu, glassmorphism, bauhaus, brutalism, healing, cozy ..." ) if not with_examples: print("💡 加 --with-examples 查看每个预设的 Lexica/Civitai/Pinterest 参考图链接（v2.4）\n") else: print("") # v2.5 C3: 变体差异轴 VARIANT_AXES_DICT: Dict[str, List[str]] = { "mood": [ "神秘 ethereal mysterious", "治愈 cozy healing soft", "史诗 epic dramatic cinematic", "高级 luxurious refined sophisticated", "梦幻 dreamy ethereal whimsical", "紧张 tense intense gripping", ], "composition": [ "特写 close-up portrait", "全身 full body wide shot", "俯拍 top-down overhead", "仰拍 low-angle hero shot", "侧面 side profile", "三分之二 three-quarter view", ], "lighting": [ "黄金时刻 golden hour warm rim light", "蓝调时刻 blue hour cool gradient", "硬光 hard directional spotlight", "柔光 soft diffused window light", "霓虹 neon multi-color rim", "侧光 side rim with deep shadows", ], "stylize": [ "stylize 50 写实", "stylize 250 平衡", "stylize 500 风格化", "stylize 750 高度风格化", ], } def build_variants(subject: str, preset: str, model: str, aspect: str, axes: List[str], n: int, seed: Optional[int] = None, quality_tier: str = "pro", mix_secondary: Optional[str] = None, mix_ratio: float = 0.6) -> List[Dict]: """v2.5 C3: 生成 N 个 A/B 测试变体。每个变体在 axes 指定的维度上选不同值，其余字段固定（含 seed）。 """ valid_axes = [a for a in axes if a in VARIANT_AXES_DICT] if not valid_axes: valid_axes = ["mood", "composition"] # 生成 N 个差异化组合 if seed is None: seed = stable_seed(subject, preset) variants = [] for i in range(n): mood = composition = lighting = "" extras_neg = "" # 每个 axis 取第 i % len(axis) 个值 for axis in valid_axes: values = VARIANT_AXES_DICT[axis] val = values[i % len(values)] # 中文部分作 mood/composition，英文部分作 prompt 注入 zh, _, en = val.partition(" ") if axis == "mood": mood = en elif axis == "composition": composition = en elif axis == "lighting": # 注入到 extras_neg 反向：实际加到 subject 后 pass # 在 subject 后面拼接 lighting / stylize 信号（让 build_prompt 不破坏锁机制） injected_subject = subject for axis in valid_axes: if axis == "lighting": _, _, en = VARIANT_AXES_DICT[axis][i % len(VARIANT_AXES_DICT[axis])].partition(" ") injected_subject = f"{subject}, {en}" elif axis == "stylize": # stylize 不改 subject，留给 MJ flag（默认 250） pass r = build_prompt( injected_subject, preset, model, aspect, extra_mood=mood, extra_composition=composition, seed=seed, quality_tier=quality_tier, mix_secondary=mix_secondary, mix_ratio=mix_ratio, ) # 描述这个变体 descriptors = [] for axis in valid_axes: zh, _, _ = VARIANT_AXES_DICT[axis][i % len(VARIANT_AXES_DICT[axis])].partition(" ") descriptors.append(f"{axis}={zh}") r["variant_index"] = i + 1 r["variant_total"] = n r["variant_descriptor"] = " / ".join(descriptors) variants.append(r) return variants def show_preset_examples(preset: str): """打印单个预设的所有平台参考图链接。""" resolved = resolve_preset(preset) or preset if resolved not in STYLE_PRESETS: print(f"❌ 未知预设: {preset}（运行 -l 查看所有预设）") return urls = preset_example_urls(resolved) data = STYLE_PRESETS[resolved] print(f"\n🎨 {resolved} ({data['category']}) — 参考图链接") print("─" * 60) print(f" 风格特征: {data['tags']}") print(f" 默认画幅: {data.get('aspect', '1:1')}") print(f" 搜索词: {PRESET_SEARCH_TERMS.get(resolved, resolved)}") print(f"\n📍 参考图平台:") for plat, url in urls.items(): print(f" • {plat:14s} {url}") print() # ───────────────────────────────────────────────────────── # CLI # ───────────────────────────────────────────────────────── def main(): parser = argparse.ArgumentParser( description=f"huo15-img-prompt v{VERSION} — T2I 提示词增强工具", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=""" 示例: # 基础 enhance_prompt.py "一只赛博朋克风格的猫" -p 赛博朋克 -m Midjourney # 自动意图 + 时间 / 天气 / 季节 / 负向需求识别 enhance_prompt.py "雨天黄昏的东京巷弄，忧郁氛围，不要人物" enhance_prompt.py "秋天樱花季汉服写真" # 新预设（v2.1） enhance_prompt.py "双马尾少女" -p 原神 -t master enhance_prompt.py "手持月亮的神女" -p 敦煌壁画 enhance_prompt.py "极简仪表盘UI" -p 玻璃拟态 # 角色设定图（给 Midjourney --cref 做参考） enhance_prompt.py "银发机甲少女" -p 动漫 --character-sheet -m Midjourney # 混合预设（v2.2） enhance_prompt.py "持剑女侠" -p "赛博朋克+水墨" --mix 0.6 -m Midjourney enhance_prompt.py "山中神女" -p "原神+敦煌壁画" --mix 0.5 -m SDXL # 系列一致性（4 张共享 camera/lighting/palette/seed） enhance_prompt.py "一个红发女侠" -p 动漫 -s 4 \\ --variations "持剑站立,骑马奔驰,弯弓射箭,与龙对视" # 质量档位 + 显式负面追加 enhance_prompt.py "品牌展台" -p 品牌KV -t master --avoid "cluttered, people" # JSON 输出 enhance_prompt.py "极简Logo一朵山茶花" -p Logo设计 -j """, ) parser.add_argument("subject", nargs="?", help="要生成图片的主体描述") parser.add_argument( "-p", "--preset", help="风格预设（中文 / 英文别名）。混合：'赛博朋克+水墨' 或 'genshin+dunhuang'（v2.2）", ) parser.add_argument( "--mix", type=float, default=0.6, help="主预设权重 0.1-0.9，仅在 -p A+B 混合时生效（默认 0.6，主导主预设）", ) parser.add_argument( "-m", "--model", default="通用", help="目标模型: Midjourney / SD / SDXL / DALL-E / Flux / 通用", ) parser.add_argument("-a", "--aspect", default="", help="画幅: 1:1 / 3:4 / 16:9 / 21:9 ...") parser.add_argument("--mood", default="", help="情绪覆盖") parser.add_argument("--composition", default="", help="构图覆盖") parser.add_argument("--avoid", default="", help="额外负面词，逗号分隔（v2.1）") parser.add_argument( "-t", "--tier", choices=["basic", "pro", "master"], default="pro", help="质量档位 basic/pro/master，默认 pro（v2.1）", ) parser.add_argument( "-cs", "--character-sheet", action="store_true", help="角色设定图模式：T-pose 多视图，适合给 MJ --cref 做角色参考（v2.1）", ) parser.add_argument("--seed", type=int, help="种子（不给则哈希生成稳定 seed）") parser.add_argument("-s", "--series", type=int, default=1, help="系列张数（配合 --variations 使用）") parser.add_argument("--variations", default="", help="系列变体，逗号分隔，如 '持剑,骑马,射箭'") parser.add_argument("--variants", type=int, default=0, help="A/B 测试：同 subject 出 N 个不同 mood/composition 变体（v2.5），可 pipe 给 image_review --rank") parser.add_argument("--variant-axes", default="mood,composition", help="变体差异轴，逗号分隔（mood/composition/lighting/stylize），默认 mood,composition（v2.5）") parser.add_argument("--polish", action="store_true", help="先用 Claude API 智能润色（需 ANTHROPIC_API_KEY）后再增强（v2.3）") parser.add_argument("--suggest", action="store_true", help="只 Claude 推荐 top-3 预设，不做完整 prompt（v2.5 A1，描述模糊时用）") parser.add_argument("--safety", default="", help="平台合规润色：DALL-E/MJ/SD/SDXL/Flux，自动重写艺术词避免误判（v2.3）") parser.add_argument("--compact", action="store_true", help="压缩 prompt 到 CLIP 77 token 内（防 SDXL 截断），自动去重 + 保留主体（v2.4）") parser.add_argument("--compact-target", type=int, default=CLIP_TOKEN_LIMIT, help=f"压缩目标 token 数，默认 {CLIP_TOKEN_LIMIT}（v2.4）") parser.add_argument("--session", default="", help="保存当前调用到 ~/.huo15/sessions/.json 供后续 --continue 使用（v2.4）") parser.add_argument("--continue", dest="cont", default="", help="加载之前的 session 作为默认值，CLI 参数为补丁，自动锁定 seed（v2.4）") parser.add_argument("--list-sessions", action="store_true", help="列出所有 session（v2.4）") parser.add_argument("--save-char", default="", help="保存当前调用为角色卡 ~/.huo15/characters/.json（v2.6）") parser.add_argument("--char", default="", help="加载角色卡，自动注入主体描述 + 锁 seed/preset/aspect（v2.6）") parser.add_argument("--obsidian", action="store_true", help="把 recipe 写入 Obsidian vault『图集/』，自动 frontmatter + 复现命令（v2.6）") parser.add_argument("--brand-kit", default="", help="加载品牌套件 ~/.huo15/brand_kits/.json，自动注入 colors/keywords/forbidden（v3.0）") parser.add_argument("-l", "--list", action="store_true", help="列出所有预设") parser.add_argument("--with-examples", action="store_true", help="-l 时附 Lexica/Civitai 参考图链接（v2.4）") parser.add_argument("--examples", help="查看单个预设的所有平台参考图链接（v2.4）") parser.add_argument("-j", "--json", action="store_true", help="JSON 输出") parser.add_argument("-v", "--version", action="version", version=f"%(prog)s v{VERSION}") args = parser.parse_args() if args.list: list_presets(with_examples=args.with_examples) return if args.examples: show_preset_examples(args.examples) return if args.list_sessions: session_list() return # v2.4 A2: --continue 加载历史 session 作为默认值 session_meta = None if args.cont: session_meta = session_apply(args.cont, args) if not session_meta.get("loaded"): print(f"⚠️ {session_meta.get('reason')}", file=sys.stderr) # v2.6 E1: --char 加载角色卡（在 session 之后，让角色卡覆盖 session） char_meta = None if args.char: try: from character import char_apply char_meta = char_apply(args.char, args) if not char_meta: print(f"⚠️ 角色卡 '{args.char}' 不存在", file=sys.stderr) except ImportError: print(f"⚠️ character 模块未找到", file=sys.stderr) # v3.0 E4: --brand-kit 加载品牌套件 brand_kit_meta = None if args.brand_kit: try: from brand_kit import kit_apply brand_kit_meta = kit_apply(args.brand_kit, args) if not brand_kit_meta: print(f"⚠️ 品牌套件 '{args.brand_kit}' 不存在", file=sys.stderr) except ImportError: print(f"⚠️ brand_kit 模块未找到", file=sys.stderr) if not args.subject: parser.print_help() sys.exit(1) # v2.5 A1: --suggest 委托 claude_polish 做 top-3 预设推荐 if args.suggest: try: from claude_polish import suggest_presets suggestion = suggest_presets(args.subject) except Exception as e: print(f"❌ {e}", file=sys.stderr) sys.exit(2) if args.json: print(json.dumps(suggestion, ensure_ascii=False, indent=2)) return print(f"\n🎯 智能预设推荐\n📝 用户意图: {suggestion.get('user_intent_summary', '')}\n") for i, p in enumerate(suggestion.get("top_3", []), 1): score = p.get("score", 0) bar = "█" * int(score * 10) + "░" * (10 - int(score * 10)) print(f" {i}. {p.get('preset', '?'):12s} [{bar}] {score:.2f} → {p.get('reason', '')}") mix = suggestion.get("mix_suggestion") or {} if mix and mix.get("primary"): print(f"\n🎨 混合建议: {mix['primary']} + {mix['secondary']} (mix={mix.get('ratio', 0.6)})") print(f" {mix.get('reason', '')}") print() return subject = args.subject polish_meta: Optional[Dict] = None safety_meta: Optional[Dict] = None preset_override = args.preset aspect_override = args.aspect mix_override = None # v2.3: Claude 智能润色（前置） if args.polish: try: sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) from claude_polish import call_claude, parse_claude_json resp = call_claude(subject) polished = parse_claude_json(resp) if polished.get("error"): print(f"❌ Claude 润色拒答: {polished['error']}", file=sys.stderr) sys.exit(2) subject = polished.get("subject_refined_zh") or subject if not preset_override: pri = polished.get("style_preset", "") sec = polished.get("style_preset_secondary", "") if pri and sec: preset_override = f"{pri}+{sec}" mix_override = polished.get("mix_ratio", 0.6) elif pri: preset_override = pri if not aspect_override and polished.get("aspect"): aspect_override = polished["aspect"] polish_meta = polished except Exception as e: print(f"⚠️ Claude 润色失败，回退到原描述: {e}", file=sys.stderr) # v2.3: 平台合规润色 if args.safety: try: from safety_lint import lint as safety_lint r = safety_lint(subject, platform=args.safety) if r["verdict"] == "REJECT": print(f"🚫 命中红线: {r['reason']}\n类别: {', '.join(r.get('categories', []))}", file=sys.stderr) print(r.get("advice", ""), file=sys.stderr) sys.exit(2) if r["verdict"] == "REWRITE": subject = r["rewritten"] safety_meta = r except ImportError: print(f"⚠️ safety_lint 模块未找到", file=sys.stderr) # 自动推荐 auto = parse_requirement(subject) raw_preset = preset_override or auto["preset_suggestion"] or "写实摄影" primary_raw, secondary_raw = parse_mix_preset(raw_preset) preset = primary_raw mix_secondary = secondary_raw # 校验混合预设 if mix_secondary: primary_resolved = resolve_preset(preset) secondary_resolved = resolve_preset(mix_secondary) if not primary_resolved or not secondary_resolved: unknown = [n for n, r in [(preset, primary_resolved), (mix_secondary, secondary_resolved)] if not r] print(f"❌ 未知预设：{', '.join(unknown)}（运行 -l 查看列表）", file=sys.stderr) sys.exit(1) preset = primary_resolved mix_secondary = secondary_resolved aspect = aspect_override or auto["aspect_suggestion"] or STYLE_PRESETS.get(resolve_preset(preset) or "写实摄影", {}).get("aspect", "1:1") # 混合权重（polish 推荐 > CLI --mix） effective_mix = mix_override if mix_override is not None else args.mix # v2.5 C3: A/B 变体模式（同 subject + 同 seed，不同 mood/composition） if args.variants > 0: axes = [a.strip() for a in args.variant_axes.split(",") if a.strip()] variants = build_variants( subject, preset, args.model, aspect, axes, args.variants, seed=args.seed, quality_tier=args.tier, mix_secondary=mix_secondary, mix_ratio=effective_mix, ) if args.json: out = {"version": VERSION, "variants": variants} print(json.dumps(out, ensure_ascii=False, indent=2)) else: print(f"🎲 A/B 变体测试 ({args.variants} 个，差异轴: {', '.join(axes)})") print(f" 所有变体共享 seed = {variants[0]['seed_suggestion']}（仅在指定轴上分化）") for v in variants: print(f"\n 变体 {v['variant_index']}/{v['variant_total']}: {v['variant_descriptor']}") print(f" positive head: {v['positive'][:120]}...") print(f"\n💡 出图后用 image_review.py img1.png img2.png ... --rank 选最优\n") return # 系列模式 if args.series > 1 or args.variations: variations = [v.strip() for v in args.variations.split(",") if v.strip()] if not variations: variations = [subject] * args.series elif len(variations) < args.series: variations += [variations[-1]] * (args.series - len(variations)) results = build_series( subject, preset, args.model, aspect, variations[: max(args.series, len(variations))], seed=args.seed, quality_tier=args.tier, mix_secondary=mix_secondary, mix_ratio=effective_mix, ) if args.json: out = {"version": VERSION, "series": results} if polish_meta: out["claude_polish"] = polish_meta if safety_meta: out["safety_lint"] = safety_meta print(json.dumps(out, ensure_ascii=False, indent=2)) else: if polish_meta: print(f"✨ Claude 已润色 → 主体: {subject}") if safety_meta and safety_meta.get("verdict") == "REWRITE": print(f"🛡 平台合规重写 → {subject}") for r in results: print_prompt(r) print(f"🔐 本系列 {len(results)} 张共享 seed = {results[0]['seed_suggestion']}，一致性锁见每张「🔒」区块。") return # 单张 result = build_prompt( subject, preset, args.model, aspect, extra_mood=args.mood, extra_composition=args.composition, extra_negatives=args.avoid, seed=args.seed, quality_tier=args.tier, character_sheet=args.character_sheet, mix_secondary=mix_secondary, mix_ratio=effective_mix, ) if polish_meta: result["claude_polish"] = polish_meta if safety_meta: result["safety_lint"] = safety_meta # v2.4: 压缩 prompt（针对 CLIP 模型） if args.compact: compacted, meta = compact_prompt(result["positive"], target_tokens=args.compact_target) result["positive_original"] = result["positive"] result["positive"] = compacted result["compaction"] = meta # v2.4 A2: 保存 session session_name = args.session or args.cont if session_name: session_save(session_name, result) result["session"] = {"name": session_name, "saved": True} if session_meta: result["session"]["loaded_from"] = session_meta # v2.6 E1: 保存角色卡 if args.save_char: try: from character import char_save saved_card = char_save(args.save_char, result) result["character_card"] = {"name": args.save_char, "saved": True} except Exception as e: print(f"⚠️ 角色卡保存失败: {e}", file=sys.stderr) # v2.6 D2: Obsidian 写入 if args.obsidian: try: obsidian_path = write_obsidian_recipe(result) result["obsidian"] = {"saved": True, "path": obsidian_path} except Exception as e: print(f"⚠️ Obsidian 写入失败: {e}", file=sys.stderr) if args.json: print(json.dumps(result, ensure_ascii=False, indent=2)) else: if char_meta: print(f"👤 已加载角色卡 '{args.char}' (用过 {char_meta.get('use_count', 1)} 次, seed={char_meta.get('seed')})") if brand_kit_meta: print(f"🎨 已加载品牌套件 '{args.brand_kit}' ({len(brand_kit_meta.get('colors', []))} 色, {len(brand_kit_meta.get('keywords', []))} 关键词)") if session_meta and session_meta.get("loaded"): applied = session_meta.get("applied_from_session", []) print(f"📂 已加载 session '{session_meta['name']}' (第 {session_meta['iteration_count']+1} 轮)") if applied: print(f" 继承字段: {', '.join(applied)}") if polish_meta: print(f"✨ Claude 已润色 (in={polish_meta.get('_usage',{}).get('input_tokens',0)}/out={polish_meta.get('_usage',{}).get('output_tokens',0)} tokens)") if safety_meta and safety_meta.get("verdict") == "REWRITE": print(f"🛡 平台合规已重写: {len(safety_meta.get('substitutions',[]))} 处替换 (target={safety_meta['platform']})") if args.compact and result.get("compaction", {}).get("compacted"): m = result["compaction"] print(f"🗜 prompt 已压缩: {m['estimated_tokens_before']}→{m['estimated_tokens_after']} tokens (砍 {m['removed']} 段)") print_prompt(result) if session_name: safe = re.sub(r"[^\w\-]", "_", session_name) print(f"💾 已保存 session: ~/.huo15/sessions/{safe}.json") if args.save_char: safe_char = re.sub(r"[^\w\-]", "_", args.save_char) print(f"👤 已保存角色卡: ~/.huo15/characters/{safe_char}.json") if result.get("obsidian", {}).get("saved"): print(f"📚 已写入 Obsidian: {result['obsidian']['path']}") if __name__ == "__main__": main() FILE:scripts/enhance_video.py #!/usr/bin/env python3 """ huo15-img-prompt — T2V 视频提示词增强脚本 v2.2 把 enhance_prompt.py 的 88 风格预设 + 一致性锁，扩展到视频维度： - 镜头运动（推/拉/摇/移/跟/环绕/手持/无人机...） - 节奏（缓慢 / 中速 / 紧张快切） - 时长（建议秒数 + 关键帧拆分） - 主体动作（自动从描述中抽词，或显式 --action） - 模型适配：Sora / Kling 可灵 / Runway Gen-3/Gen-4 / Pika / Luma DreamMachine / 即梦 / Hailuo MiniMax / Wan2.1 调用： enhance_video.py "雨夜霓虹街头一只猫漫步" -p 赛博朋克 -m Sora --duration 8 enhance_video.py "汉服少女转身回眸" -p 汉服写真 -m Kling --motion 慢速跟拍 enhance_video.py "宇宙飞船穿越星云" -p scifi -m Runway --action "ship accelerates, lens flare" 依赖： enhance_prompt.py 同目录（复用其预设 + 意图解析 + 一致性锁） """ import sys import os import json import re import argparse import hashlib from typing import Dict, List, Optional, Tuple sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) from enhance_prompt import ( STYLE_PRESETS, ALIASES, QUALITY_TIERS, resolve_preset, parse_requirement, parse_mix_preset, mix_presets, sanitize_subject, strip_negative_clauses, stable_seed, list_presets as list_image_presets, ) VERSION = "3.1.0" # ───────────────────────────────────────────────────────── # 镜头运动（中文 → 英文 + 视频专业术语） # ───────────────────────────────────────────────────────── CAMERA_MOTION: Dict[str, str] = { "推": "slow push-in (dolly in)", "推镜": "smooth dolly in, gradual close-up", "拉": "pull back (dolly out)", "拉镜": "slow pull back revealing wider scene", "摇": "pan (horizontal)", "横摇": "horizontal pan from left to right", "竖摇": "vertical tilt up to down", "移": "lateral tracking shot", "跟": "tracking shot following the subject", "跟拍": "smooth tracking shot, subject locked in frame", "环绕": "360 orbital shot around the subject", "围绕": "360 orbit shot, slow rotation", "手持": "handheld camera, slight shake, documentary feel", "稳定": "smooth gimbal stabilized, fluid motion", "无人机": "aerial drone shot, high-altitude reveal", "航拍": "aerial drone descent, cinematic reveal", "升": "crane up, vertical rise", "降": "crane down, descent", "变焦": "zoom in, focal length change", "希区柯克": "dolly zoom (vertigo effect)", "希区": "dolly zoom (vertigo effect)", "鱼眼": "fisheye lens distortion, wide warped perspective", "POV": "first-person POV, immersive", "POV视角": "first-person POV, immersive", "子弹时间": "bullet-time freeze, 360 frozen pan", "延时": "time-lapse, accelerated motion", "慢动作": "slow motion 120fps, ultra-smooth", "快切": "rapid cuts, high-energy montage", } # 节奏 → 英文 PACING: Dict[str, str] = { "缓慢": "slow steady pacing, contemplative rhythm", "舒缓": "slow steady pacing, contemplative rhythm", "宁静": "calm, atmospheric, lingering shots", "中速": "moderate pacing, balanced cuts", "紧张": "tense pacing, building intensity", "急促": "fast pacing, urgent cuts", "快切": "rapid cuts, high-energy edit", "动感": "kinetic energy, dynamic motion", "史诗": "epic crescendo, sweeping movement", } # 主体动作关键词（自动抽词） ACTION_KEYWORDS: Dict[str, str] = { "走": "walking forward", "漫步": "walking calmly", "奔跑": "running fast", "跑": "running", "跳": "jumping", "飞": "flying through the air", "舞": "dancing gracefully", "舞蹈": "dancing gracefully", "回眸": "turning to look back over shoulder", "转身": "turning around", "微笑": "smiling softly", "战斗": "fighting, dynamic combat motion", "挥剑": "swinging a sword", "射箭": "drawing and releasing an arrow", "骑马": "riding a horse at full gallop", "驾驶": "driving forward", "穿越": "traveling through, breaking forward", "升起": "rising up slowly", "落下": "falling down gently", "爆炸": "explosion blooming outward", "绽放": "blooming open", "凝视": "gazing intently into the camera", "对视": "locking eyes with the viewer", "睁眼": "eyes opening slowly", "闭眼": "eyes closing slowly", "呼吸": "breathing softly, chest rising and falling", "拥抱": "embracing tenderly", "牵手": "holding hands", "握手": "shaking hands", } # ───────────────────────────────────────────────────────── # 模型规格 # ───────────────────────────────────────────────────────── VIDEO_MODELS: Dict[str, Dict[str, str]] = { "Sora": { "max_duration": "20s (Sora 2 Pro)", "default_duration": 10, "aspect_default": "16:9", "tip": "支持长自然语言描述。可叠加 'cinematic, IMAX, 35mm film, photorealistic'。一致性强，可复用 character description。", "format": "natural", }, "Kling": { "max_duration": "10s (1080p Pro)", "default_duration": 5, "aspect_default": "16:9", "tip": "可灵 1.6/2.0：建议提示前置主体，后置镜头/光影。支持首尾帧控制（image-to-video）。", "format": "natural", }, "可灵": { "max_duration": "10s (1080p Pro)", "default_duration": 5, "aspect_default": "16:9", "tip": "可灵 1.6/2.0：中文提示词支持良好，可加 'cinematic 电影感'。", "format": "natural", }, "Runway": { "max_duration": "10s (Gen-3 Alpha Turbo)", "default_duration": 5, "aspect_default": "16:9", "tip": "Gen-3 / Gen-4：英文提示效果最佳。支持 Motion Brush 局部运动。CFG ~7。", "format": "natural", }, "Pika": { "max_duration": "10s (Pika 2.0)", "default_duration": 4, "aspect_default": "16:9", "tip": "Pika：标签式提示，支持 -gs (guidance scale) 和 -motion (1-4)。", "format": "tag", }, "Luma": { "max_duration": "9s (Dream Machine 1.6)", "default_duration": 5, "aspect_default": "16:9", "tip": "Luma Dream Machine：自然语言 + 关键帧（首尾图）。Loop 模式支持无缝循环。", "format": "natural", }, "DreamMachine": { "max_duration": "9s", "default_duration": 5, "aspect_default": "16:9", "tip": "Luma Dream Machine：自然语言 + 关键帧。", "format": "natural", }, "Hailuo": { "max_duration": "10s (MiniMax 02 / S2V-01)", "default_duration": 6, "aspect_default": "16:9", "tip": "海螺 MiniMax 02：中文支持优秀。S2V-01 可指定参考人物。", "format": "natural", }, "MiniMax": { "max_duration": "10s", "default_duration": 6, "aspect_default": "16:9", "tip": "MiniMax 视频：中英双语，长描述效果好。", "format": "natural", }, "即梦": { "max_duration": "12s (Seedance 1.0)", "default_duration": 5, "aspect_default": "16:9", "tip": "即梦 / Seedance：抖音生态，支持中文 + 多镜头剧情连贯。", "format": "natural", }, "Seedance": { "max_duration": "12s", "default_duration": 5, "aspect_default": "16:9", "tip": "Seedance 1.0：多镜头剧情连贯，支持中文。", "format": "natural", }, "Wan": { "max_duration": "8s (Wan 2.1)", "default_duration": 4, "aspect_default": "16:9", "tip": "通义 Wan 2.1：阿里开源，I2V 支持高分辨率。中英双语提示。", "format": "natural", }, "Wan2.1": { "max_duration": "8s", "default_duration": 4, "aspect_default": "16:9", "tip": "通义 Wan 2.1：阿里开源 14B / 1.3B 双参数。", "format": "natural", }, "通用": { "max_duration": "—", "default_duration": 5, "aspect_default": "16:9", "tip": "通用模板：自然语言 + 镜头 + 节奏 + 主体动作。", "format": "natural", }, } MODEL_ALIASES: Dict[str, str] = { "sora": "Sora", "kling": "Kling", "kelin": "Kling", "klingai": "Kling", "runway": "Runway", "gen3": "Runway", "gen4": "Runway", "pika": "Pika", "luma": "Luma", "dreammachine": "Luma", "hailuo": "Hailuo", "minimax": "Hailuo", "jimeng": "即梦", "seedance": "即梦", "wan": "Wan", "wan21": "Wan", "wan2.1": "Wan", "tongyi": "Wan", } def resolve_video_model(name: str) -> str: if not name: return "通用" key = name.strip().lower().replace("-", "").replace("_", "").replace(" ", "") if key in MODEL_ALIASES: return MODEL_ALIASES[key] for m in VIDEO_MODELS: if m.lower() == key: return m return name if name in VIDEO_MODELS else "通用" # ───────────────────────────────────────────────────────── # 解析 # ───────────────────────────────────────────────────────── def parse_motion(text: str) -> str: for zh, en in CAMERA_MOTION.items(): if zh in text: return en return "" def parse_pacing(text: str) -> str: for zh, en in PACING.items(): if zh in text: return en return "" def parse_action(text: str) -> str: actions = [] for zh, en in ACTION_KEYWORDS.items(): if zh in text and en not in actions: actions.append(en) return ", ".join(actions[:3]) # ───────────────────────────────────────────────────────── # 关键帧拆分 # ───────────────────────────────────────────────────────── def keyframe_breakdown(subject: str, motion: str, duration: int) -> List[Dict[str, str]]: """简单的三段式拆分：开场（建立）→ 中段（动作）→ 结尾（落点）。""" if duration <= 3: return [{"t": "0s", "desc": f"establish shot: {subject}"}] third = max(1, duration // 3) return [ {"t": "0s", "desc": f"opening: establish {subject} in scene, static composition"}, {"t": f"{third}s", "desc": f"mid: {motion or 'subject performs main action'}, peak motion"}, {"t": f"{2*third}s", "desc": f"closing: settle into resting frame, fade or hold"}, ] # ───────────────────────────────────────────────────────── # 主构建 # ───────────────────────────────────────────────────────── def build_video_prompt( subject: str, preset: str, model: str = "通用", aspect: str = "", duration: Optional[int] = None, motion: str = "", pacing: str = "", action: str = "", seed: Optional[int] = None, quality_tier: str = "pro", extra_negatives: str = "", mix_secondary: Optional[str] = None, mix_ratio: float = 0.6, ) -> Dict: preset = resolve_preset(preset) or "电影感" if mix_secondary: mix_secondary = resolve_preset(mix_secondary) or "" model = resolve_video_model(model) spec = VIDEO_MODELS[model] # 视觉锁（复用 image preset） if mix_secondary and mix_secondary != preset: data = mix_presets(preset, mix_secondary, mix_ratio, model) mixed_label = f"{preset}+{mix_secondary}@{mix_ratio:.2f}" else: data = STYLE_PRESETS[preset] mixed_label = "" # 时长 / 画幅 if duration is None: duration = spec["default_duration"] if not aspect: aspect = data.get("aspect", spec["aspect_default"]) # 自动解析 auto = parse_requirement(subject) subject_clean = sanitize_subject(strip_negative_clauses(subject)) if not motion: motion = parse_motion(subject) or "smooth gimbal stabilized, fluid motion" if not pacing: pacing = parse_pacing(subject) or "moderate pacing, balanced cuts" if not action: action = parse_action(subject) # ambient ambient_parts = [auto["time_of_day"], auto["weather"], auto["season"]] ambient = ", ".join([x for x in ambient_parts if x]) # 视觉锁字段 visual_lock = ", ".join([ x for x in [data["tags"], data.get("camera", ""), data.get("lighting", ""), data.get("palette", "")] if x ]) quality_phrase = QUALITY_TIERS.get(quality_tier, QUALITY_TIERS["pro"]) seed_key = mixed_label or preset seed_value = seed or stable_seed(subject_clean, seed_key) # 构造正向提示 if spec["format"] == "tag": # Pika 标签格式 parts = [ subject_clean, f"{motion}", f"{pacing}", visual_lock, ambient, action, quality_phrase, "cinematic video", ] positive = ", ".join([p for p in parts if p]) positive += f" -gs 12 -motion 3 -ar {aspect}" else: # 自然语言格式 sentences = [] sentences.append(f"A {duration}-second video of {subject_clean}.") sentences.append(f"Camera movement: {motion}.") if action: sentences.append(f"The subject is {action}.") sentences.append(f"Pacing: {pacing}.") sentences.append(f"Visual style: {visual_lock}.") if ambient: sentences.append(f"Atmosphere: {ambient}.") sentences.append(f"Quality: {quality_phrase}, cinematic, smooth temporal coherence, no flicker, consistent character across frames.") positive = " ".join(sentences) # 负面 base_neg = data["neg"] video_neg = ( "flicker, frame drop, motion blur artifacts, jittery camera, " "low fps, choppy motion, morphing artifacts, identity drift, " "deformed limbs mid-motion, inconsistent character, watermark" ) neg_parts = [base_neg, video_neg, extra_negatives, ", ".join(auto.get("user_negatives", []))] negative = ", ".join([x for x in neg_parts if x]) # 关键帧 keyframes = keyframe_breakdown(subject_clean, motion, duration) hint = ( f"{model} tips：\n" f" • {spec['tip']}\n" f" • 推荐时长：{duration}s（上限 {spec['max_duration']}）\n" f" • 一致性：i2v 模式可固定首帧角色 / 用 image-prompt 保持服装色彩\n" f" • seed: {seed_value}（同一 seed + 同一 prompt 在多数模型可复现）" ) return { "version": VERSION, "type": "t2v", "original": subject, "preset": preset, "mix_secondary": mix_secondary or "", "mix_label": mixed_label, "model": model, "aspect": aspect, "duration_s": duration, "max_duration": spec["max_duration"], "motion": motion, "pacing": pacing, "action": action, "time_of_day": auto.get("time_of_day", ""), "weather": auto.get("weather", ""), "season": auto.get("season", ""), "seed_suggestion": seed_value, "quality_tier": quality_tier, "positive": positive, "negative": negative, "keyframes": keyframes, "hint": hint, "consistency_lock": { "camera": data.get("camera", ""), "lighting": data.get("lighting", ""), "palette": data.get("palette", ""), "aspect": aspect, "motion": motion, }, } def print_video_prompt(r: Dict): sep = "═" * 60 print(f"\n{sep}") print(f"🎬 视频提示词（v{r['version']}）") print(f"📌 原始描述 : {r['original']}") if r.get("mix_label"): print(f"🎨 风格预设 : {r['mix_label']} (混合)") else: print(f"🎨 风格预设 : {r['preset']}") print(f"🤖 目标模型 : {r['model']}（上限 {r['max_duration']}）") print(f"📐 画幅 : {r['aspect']}") print(f"⏱ 时长 : {r['duration_s']}s") print(f"🎥 镜头运动 : {r['motion']}") print(f"🎵 节奏 : {r['pacing']}") if r.get("action"): print(f"💪 主体动作 : {r['action']}") if r.get("time_of_day") or r.get("weather") or r.get("season"): amb = ", ".join([x for x in [r.get("time_of_day", ""), r.get("weather", ""), r.get("season", "")] if x]) print(f"🌤 环境 : {amb}") print(f"⭐ 质量档位 : {r['quality_tier']}") print(f"🎲 种子建议 : {r['seed_suggestion']}") print(f"\n✅ 正向提示词：\n{r['positive']}") print(f"\n❌ 负向提示词：\n{r['negative']}") print(f"\n🎞 关键帧拆分：") for kf in r["keyframes"]: print(f" {kf['t']:>4s} {kf['desc']}") print(f"\n🔒 一致性锁：") for k, v in r["consistency_lock"].items(): if v: print(f" {k:8s}: {v}") print(f"\n💡 {r['hint']}") print(f"{sep}\n") def main(): parser = argparse.ArgumentParser( description=f"huo15-img-prompt enhance_video v{VERSION} — T2V 视频提示词增强", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=""" 示例: enhance_video.py "雨夜霓虹街头一只猫漫步" -p 赛博朋克 -m Sora --duration 8 enhance_video.py "汉服少女转身回眸" -p 汉服写真 -m Kling --motion 慢速跟拍 enhance_video.py "宇宙飞船穿越星云" -p scifi -m Runway --duration 5 --pacing 史诗 enhance_video.py "山中神女腾云" -p "原神+敦煌壁画" --mix 0.6 -m Hailuo enhance_video.py "侠客挥剑" -p 水墨 -m 即梦 --action "spinning sword strike" """, ) parser.add_argument("subject", nargs="?", help="主体描述") parser.add_argument("-p", "--preset", help="风格预设（沿用 88 款图像预设；支持 A+B 混合）") parser.add_argument("--mix", type=float, default=0.6, help="主预设权重 0.1-0.9（默认 0.6）") parser.add_argument( "-m", "--model", default="通用", help="视频模型: Sora / Kling / Runway / Pika / Luma / Hailuo / 即梦 / Wan / 通用", ) parser.add_argument("-a", "--aspect", default="", help="画幅 16:9 / 9:16 / 1:1 / 21:9") parser.add_argument("--duration", type=int, help="时长（秒），不给走模型默认") parser.add_argument("--motion", default="", help="镜头运动覆盖（中/英）") parser.add_argument("--pacing", default="", help="节奏覆盖") parser.add_argument("--action", default="", help="主体动作覆盖") parser.add_argument("--avoid", default="", help="额外负面词") parser.add_argument("-t", "--tier", choices=["basic", "pro", "master"], default="pro") parser.add_argument("--seed", type=int, help="种子") parser.add_argument("-l", "--list", action="store_true", help="列出图像预设（视频沿用）") parser.add_argument("--list-models", action="store_true", help="列出视频模型规格") parser.add_argument("-j", "--json", action="store_true", help="JSON 输出") parser.add_argument("-v", "--version", action="version", version=f"%(prog)s v{VERSION}") args = parser.parse_args() if args.list: list_image_presets() return if args.list_models: print(f"\n🎬 视频模型规格 (v{VERSION})\n" + "─" * 50) for name, spec in VIDEO_MODELS.items(): print(f"\n【{name}】") print(f" 上限时长: {spec['max_duration']}") print(f" 默认时长: {spec['default_duration']}s") print(f" 默认画幅: {spec['aspect_default']}") print(f" 说明: {spec['tip']}") return if not args.subject: parser.print_help() sys.exit(1) raw_preset = args.preset or "电影感" primary_raw, secondary_raw = parse_mix_preset(raw_preset) if secondary_raw: primary_resolved = resolve_preset(primary_raw) secondary_resolved = resolve_preset(secondary_raw) if not primary_resolved or not secondary_resolved: unknown = [n for n, r in [(primary_raw, primary_resolved), (secondary_raw, secondary_resolved)] if not r] print(f"❌ 未知预设：{', '.join(unknown)}", file=sys.stderr) sys.exit(1) preset, mix_secondary = primary_resolved, secondary_resolved else: preset, mix_secondary = primary_raw, None result = build_video_prompt( args.subject, preset, model=args.model, aspect=args.aspect, duration=args.duration, motion=args.motion, pacing=args.pacing, action=args.action, seed=args.seed, quality_tier=args.tier, extra_negatives=args.avoid, mix_secondary=mix_secondary, mix_ratio=args.mix, ) if args.json: print(json.dumps(result, ensure_ascii=False, indent=2)) else: print_video_prompt(result) if __name__ == "__main__": main() FILE:scripts/image_review.py #!/usr/bin/env python3 """ huo15-img-prompt — Claude Vision 图像评审 v2.5 把 Claude Vision 当作图像质量评审师。给一张图（本地路径或 URL）+ 原 prompt，输出五维结构化打分 + 缺陷列表 + 可执行修复建议（喂给下一轮迭代）。为什么这个能力 GPT-4o image gen / Imagen 内部做不到？ - 它们是端到端黑盒：prompt → 图，没有 prompt-image 闭环数据回流 - 我们在用户侧补这个回路，每张图都能产出 "下一轮怎么改 prompt" 的可执行指令 - 这就是 v2.5 的核心护城河：迭代提升而不是单次出图五维评分： 1. subject_match 主体准确度（图与 prompt 的吻合） 2. composition 构图（黄金分割、留白、视觉层次、引导线） 3. lighting 光影（光源逻辑、明暗关系、艺术化处理） 4. palette 色彩（和谐度、风格一致性、色温情绪） 5. technical 技术质量（锐度、噪点、artifact、anatomy 错误）调用： image_review.py /path/to/image.png --prompt "原 prompt" image_review.py https://example.com/img.png -p "..." -j > review.json image_review.py img.png --quick # 简评，只给 overall 分 image_review.py a.png b.png c.png --rank # 多图排名依赖：纯 urllib + ANTHROPIC_API_KEY，零 SDK """ import sys import os import json import base64 import argparse import re from typing import Dict, List, Optional, Tuple from urllib.request import Request, urlopen from urllib.error import HTTPError, URLError VERSION = "3.1.0" ANTHROPIC_BASE = os.environ.get("ANTHROPIC_BASE_URL", "https://api.anthropic.com") ANTHROPIC_VERSION = "2023-06-01" DEFAULT_MODEL = "claude-sonnet-4-5" # ───────────────────────────────────────────────────────── # 评审 system prompt（启用 prompt caching，多图调用省 90% token） # ───────────────────────────────────────────────────────── def build_review_system_prompt(quick: bool = False) -> str: if quick: return """你是图像质量评审师。给一张图，输出严格 JSON： {"overall_score": 0.0-10.0, "verdict": "PASS|RETRY|REJECT", "summary": "一句话总结"} PASS ≥ 7.5, RETRY 5-7.5, REJECT < 5。只输出 JSON。""" return """你是火一五图像质量评审师，专门给 T2I 出图打专业分 + 给可执行修复指令。 # 五维评分（每维 0-10 分） 1. **subject_match**（主体准确度） - 图中主体是否符合 prompt 描述？ - 数量、姿态、表情、服饰、动作是否对得上？ - 多余/缺失元素扣分 2. **composition**（构图） - 黄金分割 / 三分法 / 中心构图等运用是否合理？ - 视觉重心明确吗？引导线、留白、层次？ - 主体是否被边框切到、是否过分挤压？ 3. **lighting**（光影） - 光源逻辑统一吗？阴影方向一致？ - 光质（硬/软、暖/冷）是否符合 prompt 的氛围？ - 高光/中调/暗部分布合理？过曝/欠曝？ 4. **palette**（色彩） - 整体色调和谐吗？是否符合 prompt 风格？ - 互补色/邻近色/单色的运用？ - 色温情绪与主题契合？ 5. **technical**（技术质量） - 锐度、噪点、压缩 artifact - 解剖错误（多指、错位、扭曲） - 文字渲染（如果有） - 边缘清晰度、纹理细节 # 输出 JSON 严格 schema ```json { "subject_match": { "score": 8.5, "good_points": ["亮点 1", "亮点 2"], "issues": ["问题 1", "问题 2"] }, "composition": {"score": ..., "good_points": [...], "issues": [...]}, "lighting": {"score": ..., "good_points": [...], "issues": [...]}, "palette": {"score": ..., "good_points": [...], "issues": [...]}, "technical": {"score": ..., "good_points": [...], "issues": [...]}, "overall_score": 0.0-10.0, "verdict": "PASS|RETRY|REJECT", "actionable_fixes": [ { "target": "subject_match|composition|lighting|palette|technical", "fix": "具体怎么改 prompt（中英混合，可直接拼接）", "priority": "high|medium|low" } ], "summary": "一句话总结这张图的最强点和最弱点" } ``` # 评分标准 - **PASS** ≥ 7.5：可以发布 - **RETRY** 5-7.5：值得改一轮 - **REJECT** < 5：建议大改 prompt 或换风格 # 关键原则 - **actionable_fixes 必须能直接喂给下一轮 prompt** — 不要写"改善光线"，要写"add: golden hour rim light, soft fill from camera left" - **issues 要具体** — 不要"构图不好"，要"主体偏左被切到，建议向中心移 15%" - **good_points 也要具体** — 帮助保留下一轮的优势 - **overall_score 是加权平均**：subject_match × 0.3 + composition × 0.2 + lighting × 0.2 + palette × 0.15 + technical × 0.15 只输出 JSON，不要包 markdown 代码块，不要前缀解释。""" # ───────────────────────────────────────────────────────── # IO + Vision API 调用 # ───────────────────────────────────────────────────────── def load_image_b64(src: str) -> Tuple[str, str]: """返回 (base64_string, media_type)。""" if src.startswith(("http://", "https://")): req = Request(src, headers={"User-Agent": "huo15-review/1.0"}) with urlopen(req, timeout=30) as r: blob = r.read() else: with open(os.path.expanduser(src), "rb") as f: blob = f.read() if blob[:8] == b"\x89PNG\r\n\x1a\n": media = "image/png" elif blob[:3] == b"\xff\xd8\xff": media = "image/jpeg" elif blob[:6] in (b"GIF87a", b"GIF89a"): media = "image/gif" elif blob[:4] == b"RIFF" and blob[8:12] == b"WEBP": media = "image/webp" else: media = "image/png" return base64.b64encode(blob).decode("ascii"), media def call_claude_vision(image_src: str, prompt: str = "", quick: bool = False, model: str = DEFAULT_MODEL, max_tokens: int = 2048) -> Dict: """调用 Claude Vision 评审一张图。""" api_key = os.environ.get("ANTHROPIC_API_KEY") if not api_key: raise RuntimeError("缺少 ANTHROPIC_API_KEY 环境变量") img_b64, media_type = load_image_b64(image_src) user_content = [] user_content.append({ "type": "image", "source": {"type": "base64", "media_type": media_type, "data": img_b64}, }) if prompt: user_content.append({ "type": "text", "text": f"{prompt}\n\n请评审这张图，输出 JSON。", }) else: user_content.append({ "type": "text", "text": "请评审这张图（无原 prompt 上下文，只看视觉品质），输出 JSON。", }) body = { "model": model, "max_tokens": max_tokens, "system": [ { "type": "text", "text": build_review_system_prompt(quick=quick), "cache_control": {"type": "ephemeral"}, } ], "messages": [ {"role": "user", "content": user_content}, {"role": "assistant", "content": "{"}, ], } req = Request( f"{ANTHROPIC_BASE}/v1/messages", data=json.dumps(body).encode("utf-8"), headers={ "Content-Type": "application/json", "x-api-key": api_key, "anthropic-version": ANTHROPIC_VERSION, }, method="POST", ) try: with urlopen(req, timeout=180) as r: return json.loads(r.read().decode("utf-8")) except HTTPError as e: err_body = e.read().decode("utf-8", errors="replace") raise RuntimeError(f"Claude Vision HTTP {e.code}: {err_body}") except URLError as e: raise RuntimeError(f"Claude Vision 网络错误: {e}") def parse_review_json(resp: Dict) -> Dict: """从 Claude 响应中抽 JSON（已 prefill `{`）。""" if "error" in resp: raise RuntimeError(f"Claude API 错误: {resp['error']}") text = "" for block in resp.get("content", []): if block.get("type") == "text": text += block.get("text", "") if not text: raise RuntimeError(f"Claude 返回空内容") full = "{" + text depth = 0 end = -1 in_str = False esc = False for i, ch in enumerate(full): if esc: esc = False continue if ch == "\\": esc = True continue if ch == '"': in_str = not in_str continue if in_str: continue if ch == "{": depth += 1 elif ch == "}": depth -= 1 if depth == 0: end = i + 1 break if end == -1: raise RuntimeError(f"未找到完整 JSON: {full[:300]}") data = json.loads(full[:end]) usage = resp.get("usage", {}) data["_usage"] = { "input_tokens": usage.get("input_tokens", 0), "output_tokens": usage.get("output_tokens", 0), "cache_read_input_tokens": usage.get("cache_read_input_tokens", 0), } data["_model"] = resp.get("model", "") return data # ───────────────────────────────────────────────────────── # 评分聚合 / 显示 # ───────────────────────────────────────────────────────── SCORE_EMOJI = lambda s: "🟢" if s >= 7.5 else ("🟡" if s >= 5 else "🔴") def review_image(src: str, prompt: str = "", quick: bool = False, model: str = DEFAULT_MODEL) -> Dict: resp = call_claude_vision(src, prompt=prompt, quick=quick, model=model) parsed = parse_review_json(resp) parsed["_image"] = src return parsed def print_review(r: Dict): sep = "═" * 60 print(f"\n{sep}") print(f"🔍 Claude Vision 图像评审 v{VERSION}") print(f"📷 图像: {r.get('_image', '?')}") print(f"🤖 模型: {r.get('_model', '?')}") u = r.get("_usage", {}) print(f"📊 token: in={u.get('input_tokens',0)} / out={u.get('output_tokens',0)}") overall = r.get("overall_score", 0) verdict = r.get("verdict", "?") emoji = SCORE_EMOJI(overall) print(f"\n{emoji} 综合评分: {overall:.1f}/10 → {verdict}") if r.get("summary"): print(f"📝 总结: {r['summary']}") if "subject_match" in r: # 完整评审 print(f"\n📐 五维分项:") for dim, label in [ ("subject_match", "主体准确"), ("composition", "构图"), ("lighting", "光影"), ("palette", "色彩"), ("technical", "技术"), ]: d = r.get(dim, {}) score = d.get("score", 0) print(f" {SCORE_EMOJI(score)} {label:8s}: {score:4.1f}/10") for issue in (d.get("issues") or [])[:2]: print(f" ❌ {issue}") for good in (d.get("good_points") or [])[:1]: print(f" ✅ {good}") fixes = r.get("actionable_fixes", []) or [] if fixes: print(f"\n🔧 可执行修复（按优先级）:") order = {"high": 0, "medium": 1, "low": 2} for f in sorted(fixes, key=lambda x: order.get(x.get("priority", "low"), 3))[:5]: p = f.get("priority", "low") mark = "🔴" if p == "high" else ("🟡" if p == "medium" else "🟢") print(f" {mark} [{f.get('target', '?')}] {f.get('fix', '')}") print(f"{sep}\n") def rank_images(srcs: List[str], prompt: str = "", quick: bool = True, model: str = DEFAULT_MODEL) -> List[Dict]: """多图排名：调用 review_image 然后按 overall_score 排序。""" results = [] for s in srcs: try: r = review_image(s, prompt=prompt, quick=quick, model=model) results.append(r) except Exception as e: results.append({"_image": s, "error": str(e), "overall_score": 0}) results.sort(key=lambda x: x.get("overall_score", 0), reverse=True) return results def print_ranking(ranked: List[Dict]): sep = "═" * 60 print(f"\n{sep}") print(f"🏆 多图评审排名 (n={len(ranked)})") print(f"{sep}") for i, r in enumerate(ranked, 1): score = r.get("overall_score", 0) emoji = SCORE_EMOJI(score) if r.get("error"): print(f" {i}. ❌ {r.get('_image', '?')}: {r['error']}") else: print(f" {i}. {emoji} {score:4.1f}/10 {r.get('_image', '?')}") if r.get("summary"): print(f" {r['summary']}") print(f"{sep}\n") def main(): parser = argparse.ArgumentParser( description=f"huo15-img-prompt image_review v{VERSION} — Claude Vision 图像评审", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=""" 示例: image_review.py /path/to/image.png --prompt "原 prompt" image_review.py https://example.com/img.png -p "..." -j > review.json image_review.py img.png --quick # 简评只给 overall image_review.py a.png b.png c.png --rank # 多图排名（自动 quick）环境变量: ANTHROPIC_API_KEY 必填 """, ) parser.add_argument("images", nargs="+", help="图片路径或 URL（支持多个走排名）") parser.add_argument("-p", "--prompt", default="", help="原始生成 prompt（评审参考）") parser.add_argument("--quick", action="store_true", help="简评模式（只 overall_score）") parser.add_argument("--rank", action="store_true", help="多图排名（自动 quick）") parser.add_argument("--model", default=DEFAULT_MODEL, help=f"Claude 模型（默认 {DEFAULT_MODEL}）") parser.add_argument("-j", "--json", action="store_true", help="JSON 输出") parser.add_argument("-v", "--version", action="version", version=f"%(prog)s v{VERSION}") args = parser.parse_args() try: if args.rank or len(args.images) > 1: ranked = rank_images(args.images, prompt=args.prompt, quick=args.quick or args.rank, model=args.model) if args.json: print(json.dumps({"version": VERSION, "ranked": ranked}, ensure_ascii=False, indent=2)) else: print_ranking(ranked) else: r = review_image(args.images[0], prompt=args.prompt, quick=args.quick, model=args.model) if args.json: print(json.dumps(r, ensure_ascii=False, indent=2)) else: print_review(r) except RuntimeError as e: print(f"❌ {e}", file=sys.stderr) sys.exit(2) if __name__ == "__main__": main() FILE:scripts/mcp_server.py #!/usr/bin/env python3 """ huo15-img-prompt — MCP stdio server v2.6 让 Claude Code / Cursor / Cline / Continue.dev 等支持 MCP 的 IDE 直接调用本技能。启动方式：python3 mcp_server.py（stdio 模式）注册到 Claude Code：~/.claude/mcp.json { "mcpServers": { "huo15-img-prompt": { "command": "python3", "args": ["/path/to/huo15-img-prompt/scripts/mcp_server.py"] } } } 注册到 Cursor / Continue.dev：参考各 IDE MCP 配置文档。实现协议：MCP 2024-11-05（JSON-RPC 2.0 over stdio），手写零依赖。支持 method：initialize / tools/list / tools/call。 """ import sys import os import json import re import traceback from typing import Dict, List, Optional, Any sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) from enhance_prompt import ( build_prompt, parse_mix_preset, resolve_preset, parse_requirement, STYLE_PRESETS, list_presets as _list_presets, preset_example_urls, compact_prompt, ) from character import char_load, char_list, char_save VERSION = "3.1.0" SERVER_INFO = {"name": "huo15-img-prompt", "version": VERSION} PROTOCOL_VERSION = "2024-11-05" # ───────────────────────────────────────────────────────── # Tools 定义 # ───────────────────────────────────────────────────────── TOOLS = [ { "name": "enhance_prompt", "description": "把一句话主体描述增强成专业 T2I 提示词。返回 positive/negative + camera/lighting/palette 五锁 + seed。支持 88 风格预设 + 混合（'A+B' 语法）。", "inputSchema": { "type": "object", "properties": { "subject": {"type": "string", "description": "主体描述（中文/英文均可）"}, "preset": {"type": "string", "description": "风格预设。88 个可选，支持 'A+B' 混合，例：'赛博朋克' / '原神+敦煌壁画'"}, "model": {"type": "string", "enum": ["Midjourney", "SD", "SDXL", "DALL-E", "Flux", "通用"], "default": "通用"}, "aspect": {"type": "string", "description": "画幅 1:1/3:4/16:9/21:9/9:16，不给走预设默认", "default": ""}, "tier": {"type": "string", "enum": ["basic", "pro", "master"], "default": "pro"}, "mix_ratio": {"type": "number", "default": 0.6, "description": "混合预设主权重 0.1-0.9"}, "compact": {"type": "boolean", "default": False, "description": "压缩到 CLIP 77 token 内"}, "seed": {"type": "integer", "description": "种子，不给则按 subject+preset 哈希"}, }, "required": ["subject"], }, }, { "name": "list_presets", "description": "列出全部 88 风格预设，按 9 大类分组（摄影/动漫/插画/3D/设计/艺术/场景/游戏/东方）。", "inputSchema": {"type": "object", "properties": {}}, }, { "name": "preset_examples", "description": "查看一个预设的 5 平台参考图链接（Lexica/Civitai/Pinterest/Google/Unsplash）。", "inputSchema": { "type": "object", "properties": { "preset": {"type": "string", "description": "预设名（中文或英文别名）"}, }, "required": ["preset"], }, }, { "name": "suggest_presets", "description": "Claude 智能推荐 top-3 预设（描述模糊时用，例如『温柔感』『高级感』）。需要 ANTHROPIC_API_KEY。", "inputSchema": { "type": "object", "properties": { "description": {"type": "string", "description": "用户描述"}, }, "required": ["description"], }, }, { "name": "polish_prompt", "description": "Claude API 智能润色：把粗糙描述转专业摄影/绘画术语。需要 ANTHROPIC_API_KEY。", "inputSchema": { "type": "object", "properties": { "subject": {"type": "string", "description": "原始描述"}, }, "required": ["subject"], }, }, { "name": "safety_lint", "description": "平台合规检查 + 艺术化重写。仅服务合法艺术创作；CSAM/真人色情/武器制造等红线直接拒答。", "inputSchema": { "type": "object", "properties": { "text": {"type": "string"}, "platform": {"type": "string", "enum": ["DALL-E", "MJ", "SD", "SDXL", "Flux", "通用"], "default": "MJ"}, }, "required": ["text"], }, }, { "name": "review_image", "description": "Claude Vision 五维评审一张图（subject_match/composition/lighting/palette/technical 各 0-10），输出可执行修复指令。需要 ANTHROPIC_API_KEY。", "inputSchema": { "type": "object", "properties": { "image": {"type": "string", "description": "图片本地路径或 URL"}, "prompt": {"type": "string", "description": "原始 prompt（评审参考）", "default": ""}, "quick": {"type": "boolean", "default": False, "description": "简评模式（只 overall_score）"}, }, "required": ["image"], }, }, { "name": "list_characters", "description": "列出已存的角色卡（~/.huo15/characters/）。", "inputSchema": {"type": "object", "properties": {}}, }, { "name": "load_character", "description": "加载角色卡：返回 subject_description + seed + preset 等锁定参数，下游可直接复用保持角色一致性。", "inputSchema": { "type": "object", "properties": { "name": {"type": "string"}, }, "required": ["name"], }, }, ] # ───────────────────────────────────────────────────────── # Tool 实现（dispatch 到具体函数） # ───────────────────────────────────────────────────────── def tool_enhance_prompt(args: Dict) -> Dict: subject = args["subject"] raw_preset = args.get("preset") or "写实摄影" primary, secondary = parse_mix_preset(raw_preset) if secondary: p1, p2 = resolve_preset(primary), resolve_preset(secondary) if not p1 or not p2: raise ValueError(f"未知预设: {primary} 或 {secondary}") preset, mix_secondary = p1, p2 else: preset = resolve_preset(primary) or "写实摄影" mix_secondary = None model = args.get("model", "通用") aspect = args.get("aspect") or STYLE_PRESETS[preset].get("aspect", "1:1") tier = args.get("tier", "pro") mix_ratio = args.get("mix_ratio", 0.6) result = build_prompt( subject, preset, model, aspect, seed=args.get("seed"), quality_tier=tier, mix_secondary=mix_secondary, mix_ratio=mix_ratio, ) if args.get("compact"): compacted, meta = compact_prompt(result["positive"]) result["positive_original"] = result["positive"] result["positive"] = compacted result["compaction"] = meta return result def tool_list_presets(args: Dict) -> Dict: by_cat: Dict[str, List[str]] = {} for name, data in STYLE_PRESETS.items(): by_cat.setdefault(data["category"], []).append(name) return {"total": len(STYLE_PRESETS), "by_category": by_cat} def tool_preset_examples(args: Dict) -> Dict: preset = args["preset"] resolved = resolve_preset(preset) or preset if resolved not in STYLE_PRESETS: raise ValueError(f"未知预设: {preset}") return { "preset": resolved, "category": STYLE_PRESETS[resolved]["category"], "tags": STYLE_PRESETS[resolved]["tags"], "default_aspect": STYLE_PRESETS[resolved].get("aspect"), "search_urls": preset_example_urls(resolved), } def tool_suggest_presets(args: Dict) -> Dict: from claude_polish import suggest_presets return suggest_presets(args["description"]) def tool_polish_prompt(args: Dict) -> Dict: from claude_polish import call_claude, parse_claude_json resp = call_claude(args["subject"]) return parse_claude_json(resp) def tool_safety_lint(args: Dict) -> Dict: from safety_lint import lint return lint(args["text"], platform=args.get("platform", "MJ")) def tool_review_image(args: Dict) -> Dict: from image_review import review_image return review_image(args["image"], prompt=args.get("prompt", ""), quick=args.get("quick", False)) def tool_list_characters(args: Dict) -> Dict: return {"characters": char_list()} def tool_load_character(args: Dict) -> Dict: card = char_load(args["name"]) if not card: raise ValueError(f"角色卡不存在: {args['name']}") return card TOOL_DISPATCH = { "enhance_prompt": tool_enhance_prompt, "list_presets": tool_list_presets, "preset_examples": tool_preset_examples, "suggest_presets": tool_suggest_presets, "polish_prompt": tool_polish_prompt, "safety_lint": tool_safety_lint, "review_image": tool_review_image, "list_characters": tool_list_characters, "load_character": tool_load_character, } # ───────────────────────────────────────────────────────── # JSON-RPC 协议 # ───────────────────────────────────────────────────────── def make_response(req_id: Any, result: Any = None, error: Optional[Dict] = None) -> Dict: resp = {"jsonrpc": "2.0", "id": req_id} if error is not None: resp["error"] = error else: resp["result"] = result return resp def handle_request(req: Dict) -> Optional[Dict]: """处理一个 JSON-RPC 请求。返回响应或 None（通知不回复）。""" method = req.get("method") req_id = req.get("id") params = req.get("params") or {} # 通知（无 id）不回复 if req_id is None: return None try: if method == "initialize": return make_response(req_id, { "protocolVersion": PROTOCOL_VERSION, "capabilities": {"tools": {}}, "serverInfo": SERVER_INFO, }) elif method == "tools/list": return make_response(req_id, {"tools": TOOLS}) elif method == "tools/call": tool_name = params.get("name") tool_args = params.get("arguments") or {} if tool_name not in TOOL_DISPATCH: return make_response(req_id, error={ "code": -32601, "message": f"Unknown tool: {tool_name}", }) try: result = TOOL_DISPATCH[tool_name](tool_args) except Exception as e: return make_response(req_id, result={ "content": [{"type": "text", "text": f"Error: {e}\n{traceback.format_exc()}"}], "isError": True, }) # MCP tools/call 标准返回格式 return make_response(req_id, { "content": [{"type": "text", "text": json.dumps(result, ensure_ascii=False, indent=2)}], }) elif method in ("ping",): return make_response(req_id, {}) else: return make_response(req_id, error={ "code": -32601, "message": f"Method not found: {method}", }) except Exception as e: return make_response(req_id, error={ "code": -32603, "message": f"Internal error: {e}", "data": {"traceback": traceback.format_exc()}, }) def serve_stdio(): """主循环：从 stdin 读 JSON-RPC，写到 stdout（按 LSP framing 或裸 JSON 行）。""" while True: try: line = sys.stdin.readline() if not line: break line = line.strip() if not line: continue try: req = json.loads(line) except json.JSONDecodeError: continue # 支持 batch（数组） if isinstance(req, list): resps = [handle_request(r) for r in req] resps = [r for r in resps if r is not None] if resps: sys.stdout.write(json.dumps(resps, ensure_ascii=False) + "\n") sys.stdout.flush() else: resp = handle_request(req) if resp is not None: sys.stdout.write(json.dumps(resp, ensure_ascii=False) + "\n") sys.stdout.flush() except KeyboardInterrupt: break except Exception as e: # 写错误到 stderr，不影响协议流 sys.stderr.write(f"[mcp_server] error: {e}\n") sys.stderr.flush() def main(): if len(sys.argv) > 1 and sys.argv[1] in ("-v", "--version"): print(f"mcp_server.py v{VERSION}") return if len(sys.argv) > 1 and sys.argv[1] in ("-h", "--help"): print(__doc__) return serve_stdio() if __name__ == "__main__": main() FILE:scripts/render_prompt.py #!/usr/bin/env python3 """ huo15-img-prompt — 提示词直出图片 v2.2 把 enhance_prompt.py 生成的提示词，直接调用本地或云端 API 出图。支持的后端： - comfyui 本地 ComfyUI（HTTP API，默认 http://127.0.0.1:8188） - sd-webui AUTOMATIC1111 / Forge（默认 http://127.0.0.1:7860/sdapi/v1/txt2img） - dalle OpenAI DALL-E 3（OPENAI_API_KEY） - openai 同 dalle - none 只生成调用脚本，不真实执行（dry-run，方便贴到 ComfyUI 桌面端）依赖：仅 Python 标准库（urllib），不引入 requests/PIL，避免企业扫描器命中第三方包。调用： render_prompt.py "赛博朋克猫" -p 赛博朋克 -m SD --backend sd-webui render_prompt.py "极简logo" -p Logo设计 --backend dalle --size 1024x1024 render_prompt.py "原神少女" -p 原神 --backend comfyui --workflow ./workflows/sdxl-base.json render_prompt.py "敦煌神女" -p 敦煌壁画 --backend none -j > recipe.json # dry-run 环境变量： OPENAI_API_KEY DALL-E 调用必需 COMFYUI_URL 覆盖 ComfyUI 端点（默认 http://127.0.0.1:8188） SDWEBUI_URL 覆盖 SD WebUI 端点（默认 http://127.0.0.1:7860） """ import sys import os import json import time import base64 import argparse import uuid from typing import Dict, Optional from urllib.parse import urljoin from urllib.request import Request, urlopen from urllib.error import HTTPError, URLError sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) from enhance_prompt import ( build_prompt, parse_mix_preset, resolve_preset, parse_requirement, STYLE_PRESETS, ASPECT_TO_SDXL, ) VERSION = "3.1.0" # ───────────────────────────────────────────────────────── # HTTP 工具 # ───────────────────────────────────────────────────────── def http_post_json(url: str, body: Dict, headers: Optional[Dict] = None, timeout: int = 600) -> Dict: data = json.dumps(body).encode("utf-8") h = {"Content-Type": "application/json"} if headers: h.update(headers) req = Request(url, data=data, headers=h, method="POST") with urlopen(req, timeout=timeout) as r: return json.loads(r.read().decode("utf-8")) def http_get_json(url: str, headers: Optional[Dict] = None, timeout: int = 60) -> Dict: req = Request(url, headers=headers or {}) with urlopen(req, timeout=timeout) as r: return json.loads(r.read().decode("utf-8")) def http_get_bytes(url: str, headers: Optional[Dict] = None, timeout: int = 600) -> bytes: req = Request(url, headers=headers or {}) with urlopen(req, timeout=timeout) as r: return r.read() # ───────────────────────────────────────────────────────── # DALL-E 3 # ───────────────────────────────────────────────────────── DALLE_SIZES = {"1:1": "1024x1024", "16:9": "1792x1024", "9:16": "1024x1792"} def render_dalle(positive: str, size: str, output_dir: str, n: int = 1) -> Dict: api_key = os.environ.get("OPENAI_API_KEY") if not api_key: raise RuntimeError("缺少 OPENAI_API_KEY 环境变量") body = { "model": "dall-e-3", "prompt": positive[:4000], "n": n, "size": size, "quality": "hd", "response_format": "b64_json", } resp = http_post_json( "https://api.openai.com/v1/images/generations", body, headers={"Authorization": f"Bearer {api_key}"}, timeout=300, ) saved = [] os.makedirs(output_dir, exist_ok=True) for i, item in enumerate(resp.get("data", [])): path = os.path.join(output_dir, f"dalle-{int(time.time())}-{i}.png") with open(path, "wb") as f: f.write(base64.b64decode(item["b64_json"])) saved.append(path) return {"backend": "dalle", "saved": saved, "raw_response_keys": list(resp.keys())} # ───────────────────────────────────────────────────────── # AUTOMATIC1111 / Forge SD WebUI # ───────────────────────────────────────────────────────── def aspect_to_size(aspect: str) -> tuple: sdxl = ASPECT_TO_SDXL.get(aspect, "1024x1024") w, h = sdxl.split("x") return int(w), int(h) def render_sdwebui(positive: str, negative: str, aspect: str, seed: int, steps: int, cfg: float, sampler: str, output_dir: str, base_url: Optional[str] = None) -> Dict: base = base_url or os.environ.get("SDWEBUI_URL", "http://127.0.0.1:7860") w, h = aspect_to_size(aspect) body = { "prompt": positive, "negative_prompt": negative, "width": w, "height": h, "seed": seed, "steps": steps, "cfg_scale": cfg, "sampler_name": sampler, "send_images": True, } resp = http_post_json(urljoin(base, "/sdapi/v1/txt2img"), body, timeout=900) saved = [] os.makedirs(output_dir, exist_ok=True) for i, b64 in enumerate(resp.get("images", [])): path = os.path.join(output_dir, f"sdwebui-{seed}-{i}.png") with open(path, "wb") as f: f.write(base64.b64decode(b64.split(",", 1)[-1])) saved.append(path) return {"backend": "sd-webui", "saved": saved, "info": resp.get("info", "")[:200]} # ───────────────────────────────────────────────────────── # ComfyUI # ───────────────────────────────────────────────────────── DEFAULT_COMFY_WORKFLOW = { "3": { "class_type": "KSampler", "inputs": { "seed": 0, "steps": 25, "cfg": 7.0, "sampler_name": "dpmpp_2m", "scheduler": "karras", "denoise": 1.0, "model": ["4", 0], "positive": ["6", 0], "negative": ["7", 0], "latent_image": ["5", 0], }, }, "4": {"class_type": "CheckpointLoaderSimple", "inputs": {"ckpt_name": "sd_xl_base_1.0.safetensors"}}, "5": {"class_type": "EmptyLatentImage", "inputs": {"width": 1024, "height": 1024, "batch_size": 1}}, "6": {"class_type": "CLIPTextEncode", "inputs": {"text": "POSITIVE_PLACEHOLDER", "clip": ["4", 1]}}, "7": {"class_type": "CLIPTextEncode", "inputs": {"text": "NEGATIVE_PLACEHOLDER", "clip": ["4", 1]}}, "8": {"class_type": "VAEDecode", "inputs": {"samples": ["3", 0], "vae": ["4", 2]}}, "9": {"class_type": "SaveImage", "inputs": {"images": ["8", 0], "filename_prefix": "huo15"}}, } def render_comfyui(positive: str, negative: str, aspect: str, seed: int, steps: int, cfg: float, workflow_path: Optional[str], output_dir: str, base_url: Optional[str] = None) -> Dict: base = base_url or os.environ.get("COMFYUI_URL", "http://127.0.0.1:8188") if workflow_path and os.path.isfile(workflow_path): with open(workflow_path, "r", encoding="utf-8") as f: workflow = json.load(f) else: workflow = json.loads(json.dumps(DEFAULT_COMFY_WORKFLOW)) w, h = aspect_to_size(aspect) for node in workflow.values(): ct = node.get("class_type", "") ins = node.get("inputs", {}) if ct == "CLIPTextEncode": if ins.get("text") == "POSITIVE_PLACEHOLDER" or "positive" in str(ins.get("text", "")).lower(): ins["text"] = positive elif ins.get("text") == "NEGATIVE_PLACEHOLDER" or "negative" in str(ins.get("text", "")).lower(): ins["text"] = negative elif ct == "EmptyLatentImage": ins["width"], ins["height"] = w, h elif ct == "KSampler": ins["seed"], ins["steps"], ins["cfg"] = seed, steps, cfg pos_set = neg_set = False for node in workflow.values(): if node.get("class_type") == "CLIPTextEncode": if not pos_set: node["inputs"]["text"] = positive pos_set = True elif not neg_set: node["inputs"]["text"] = negative neg_set = True client_id = str(uuid.uuid4()) queue_resp = http_post_json(urljoin(base, "/prompt"), {"prompt": workflow, "client_id": client_id}, timeout=30) prompt_id = queue_resp.get("prompt_id") if not prompt_id: raise RuntimeError(f"ComfyUI 队列失败: {queue_resp}") deadline = time.time() + 600 history = {} while time.time() < deadline: try: history = http_get_json(urljoin(base, f"/history/{prompt_id}"), timeout=10) if history.get(prompt_id): break except (HTTPError, URLError): pass time.sleep(2) if not history.get(prompt_id): raise RuntimeError("ComfyUI 任务超时") saved = [] os.makedirs(output_dir, exist_ok=True) outputs = history[prompt_id].get("outputs", {}) for node_id, output in outputs.items(): for img in output.get("images", []): url = urljoin(base, f"/view?filename={img['filename']}&subfolder={img.get('subfolder','')}&type={img.get('type','output')}") path = os.path.join(output_dir, f"comfy-{seed}-{img['filename']}") with open(path, "wb") as f: f.write(http_get_bytes(url)) saved.append(path) return {"backend": "comfyui", "saved": saved, "prompt_id": prompt_id} # ───────────────────────────────────────────────────────── # Replicate（v2.4）— 一键调任意开源模型 # ───────────────────────────────────────────────────────── def render_replicate(positive: str, negative: str, aspect: str, seed: int, model_ref: str, output_dir: str, steps: int = 25, cfg: float = 7.0) -> Dict: """调用 Replicate API。 model_ref 形如 'black-forest-labs/flux-schnell' 或 'stability-ai/sdxl'。 """ api_key = os.environ.get("REPLICATE_API_TOKEN") if not api_key: raise RuntimeError("缺少 REPLICATE_API_TOKEN 环境变量") w, h = aspect_to_size(aspect) body = { "input": { "prompt": positive, "negative_prompt": negative, "width": w, "height": h, "num_outputs": 1, "seed": seed, "num_inference_steps": steps, "guidance_scale": cfg, "aspect_ratio": aspect, } } if "/" in model_ref: url = f"https://api.replicate.com/v1/models/{model_ref}/predictions" else: url = f"https://api.replicate.com/v1/predictions" body["version"] = model_ref resp = http_post_json(url, body, headers={"Authorization": f"Bearer {api_key}", "Prefer": "wait"}, timeout=600) # 等待完成（如果 prefer:wait 不够） pred_id = resp.get("id", "") deadline = time.time() + 600 while resp.get("status") not in ("succeeded", "failed", "canceled"): if time.time() > deadline: raise RuntimeError("Replicate 任务超时") time.sleep(2) resp = http_get_json(f"https://api.replicate.com/v1/predictions/{pred_id}", headers={"Authorization": f"Bearer {api_key}"}) if resp.get("status") != "succeeded": raise RuntimeError(f"Replicate 失败: {resp.get('error', resp.get('status'))}") saved = [] os.makedirs(output_dir, exist_ok=True) output = resp.get("output") urls = output if isinstance(output, list) else [output] for i, img_url in enumerate(urls): if not img_url: continue path = os.path.join(output_dir, f"replicate-{seed}-{i}.png") with open(path, "wb") as f: f.write(http_get_bytes(img_url)) saved.append(path) return {"backend": "replicate", "saved": saved, "model": model_ref, "prediction_id": pred_id} # ───────────────────────────────────────────────────────── # Fal.ai（v2.4）— 速度型推理服务 # ───────────────────────────────────────────────────────── def render_fal(positive: str, negative: str, aspect: str, seed: int, model_ref: str, output_dir: str, steps: int = 25) -> Dict: """调用 Fal.ai API。 model_ref 形如 'fal-ai/flux/schnell' 或 'fal-ai/stable-diffusion-v3-medium'。 """ api_key = os.environ.get("FAL_KEY") or os.environ.get("FAL_API_KEY") if not api_key: raise RuntimeError("缺少 FAL_KEY 环境变量") w, h = aspect_to_size(aspect) body = { "prompt": positive, "negative_prompt": negative, "image_size": {"width": w, "height": h}, "seed": seed, "num_inference_steps": steps, "num_images": 1, "enable_safety_checker": True, } url = f"https://fal.run/{model_ref}" resp = http_post_json(url, body, headers={"Authorization": f"Key {api_key}"}, timeout=300) saved = [] os.makedirs(output_dir, exist_ok=True) images = resp.get("images", []) for i, img in enumerate(images): img_url = img.get("url") if isinstance(img, dict) else img if not img_url: continue path = os.path.join(output_dir, f"fal-{seed}-{i}.png") with open(path, "wb") as f: f.write(http_get_bytes(img_url)) saved.append(path) return {"backend": "fal", "saved": saved, "model": model_ref} # ───────────────────────────────────────────────────────── # 即梦 / 可灵 / Hailuo（v2.4）— 国产模型适配 # ───────────────────────────────────────────────────────── def render_jimeng(positive: str, negative: str, aspect: str, seed: int, output_dir: str) -> Dict: """字节即梦 / Seedream API。需要 ARK_API_KEY (火山方舟)。走火山方舟 OpenAPI compatible 接口。 """ api_key = os.environ.get("ARK_API_KEY") or os.environ.get("JIMENG_API_KEY") if not api_key: raise RuntimeError("缺少 ARK_API_KEY 环境变量（火山方舟）") w, h = aspect_to_size(aspect) body = { "model": os.environ.get("JIMENG_MODEL", "doubao-seedream-3-0-t2i-250415"), "prompt": positive, "size": f"{w}x{h}", "seed": seed, "guidance_scale": 7.5, "watermark": False, } resp = http_post_json( "https://ark.cn-beijing.volces.com/api/v3/images/generations", body, headers={"Authorization": f"Bearer {api_key}"}, timeout=300, ) saved = [] os.makedirs(output_dir, exist_ok=True) for i, item in enumerate(resp.get("data", [])): img_url = item.get("url") if not img_url: continue path = os.path.join(output_dir, f"jimeng-{seed}-{i}.png") with open(path, "wb") as f: f.write(http_get_bytes(img_url)) saved.append(path) return {"backend": "jimeng", "saved": saved, "model": body["model"]} def render_kling(positive: str, negative: str, aspect: str, seed: int, output_dir: str) -> Dict: """快手可灵图像 API。需要 KLING_ACCESS_KEY + KLING_SECRET_KEY（JWT 自签）。可灵 API 走 JWT 鉴权（HMAC-SHA256）。这里实现最简单的密钥模式。 """ api_key = os.environ.get("KLING_API_KEY") if not api_key: raise RuntimeError("缺少 KLING_API_KEY 环境变量") w, h = aspect_to_size(aspect) body = { "model_name": "kling-v1", "prompt": positive, "negative_prompt": negative, "aspect_ratio": aspect, "n": 1, } # 提交任务 resp = http_post_json( "https://api.klingai.com/v1/images/generations", body, headers={"Authorization": f"Bearer {api_key}"}, timeout=60, ) task_id = (resp.get("data") or {}).get("task_id", "") if not task_id: raise RuntimeError(f"可灵任务创建失败: {resp}") # 轮询 deadline = time.time() + 300 images = [] while time.time() < deadline: status_resp = http_get_json( f"https://api.klingai.com/v1/images/generations/{task_id}", headers={"Authorization": f"Bearer {api_key}"}, ) data = status_resp.get("data") or {} if data.get("task_status") == "succeed": images = (data.get("task_result") or {}).get("images", []) break if data.get("task_status") == "failed": raise RuntimeError(f"可灵任务失败: {data.get('task_status_msg')}") time.sleep(3) saved = [] os.makedirs(output_dir, exist_ok=True) for i, img in enumerate(images): img_url = img.get("url") if isinstance(img, dict) else img if not img_url: continue path = os.path.join(output_dir, f"kling-{seed}-{i}.png") with open(path, "wb") as f: f.write(http_get_bytes(img_url)) saved.append(path) return {"backend": "kling", "saved": saved, "task_id": task_id} def render_hailuo(positive: str, negative: str, aspect: str, seed: int, output_dir: str) -> Dict: """海螺 MiniMax 图像 API。需要 MINIMAX_API_KEY。""" api_key = os.environ.get("MINIMAX_API_KEY") or os.environ.get("HAILUO_API_KEY") if not api_key: raise RuntimeError("缺少 MINIMAX_API_KEY 环境变量") w, h = aspect_to_size(aspect) body = { "model": os.environ.get("MINIMAX_IMAGE_MODEL", "image-01"), "prompt": positive, "aspect_ratio": aspect, "n": 1, "response_format": "url", "seed": seed, } resp = http_post_json( "https://api.minimaxi.chat/v1/image_generation", body, headers={"Authorization": f"Bearer {api_key}"}, timeout=300, ) saved = [] os.makedirs(output_dir, exist_ok=True) data = resp.get("data") or {} image_urls = data.get("image_urls") or [] if not image_urls: for item in resp.get("data", []) if isinstance(resp.get("data"), list) else []: if isinstance(item, dict) and item.get("url"): image_urls.append(item["url"]) for i, img_url in enumerate(image_urls): if not img_url: continue path = os.path.join(output_dir, f"hailuo-{seed}-{i}.png") with open(path, "wb") as f: f.write(http_get_bytes(img_url)) saved.append(path) return {"backend": "hailuo", "saved": saved, "model": body["model"]} # ───────────────────────────────────────────────────────── # 主入口 # ───────────────────────────────────────────────────────── def main(): parser = argparse.ArgumentParser( description=f"huo15-img-prompt render_prompt v{VERSION} — 提示词直出图片", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=""" 示例: render_prompt.py "赛博朋克猫" -p 赛博朋克 --backend sd-webui render_prompt.py "原神少女" -p 原神 --backend comfyui --workflow ./workflows/sdxl.json render_prompt.py "极简logo" -p Logo设计 --backend dalle --size 1024x1024 render_prompt.py "敦煌神女" -p 敦煌壁画 --backend none -j # dry-run，只输出 recipe # v2.4 新后端： render_prompt.py "侠客" -p 水墨 --backend replicate --remote-model black-forest-labs/flux-schnell render_prompt.py "猫" -p 动漫 --backend fal --remote-model fal-ai/flux/dev render_prompt.py "敦煌神女" -p 敦煌壁画 --backend jimeng # 字节即梦（火山方舟） render_prompt.py "汉服少女" -p 汉服写真 --backend kling # 快手可灵 render_prompt.py "原神少女" -p 原神 --backend hailuo # 海螺 MiniMax """, ) parser.add_argument("subject", help="主体描述") parser.add_argument("-p", "--preset", help="风格预设（支持 A+B 混合）") parser.add_argument("--mix", type=float, default=0.6, help="混合权重（默认 0.6）") parser.add_argument("-a", "--aspect", default="", help="画幅") parser.add_argument("-t", "--tier", choices=["basic", "pro", "master"], default="pro") parser.add_argument("--avoid", default="", help="额外负面词") parser.add_argument("--seed", type=int, help="种子") parser.add_argument( "--backend", choices=["comfyui", "sd-webui", "dalle", "openai", "replicate", "fal", "jimeng", "kling", "hailuo", "minimax", "none"], default="none", help="后端：comfyui/sd-webui/dalle | replicate/fal | jimeng/kling/hailuo | none(dry-run)（v2.4 扩 7 后端）", ) parser.add_argument( "--remote-model", default="", help="Replicate/Fal 模型 ref，例: 'black-forest-labs/flux-schnell' / 'fal-ai/flux/schnell'", ) parser.add_argument("-m", "--model", default="SDXL", help="提示词模型适配（不影响后端选择）") parser.add_argument("--output", default="./renders", help="输出目录（默认 ./renders）") parser.add_argument("--workflow", default="", help="ComfyUI workflow JSON 路径（可选）") parser.add_argument("--steps", type=int, default=25, help="采样步数") parser.add_argument("--cfg", type=float, default=7.0, help="CFG scale") parser.add_argument("--sampler", default="DPM++ 2M Karras", help="采样器") parser.add_argument("--size", default="", help="DALL-E 尺寸 1024x1024 / 1792x1024 / 1024x1792") parser.add_argument("--n", type=int, default=1, help="生成张数（DALL-E）") parser.add_argument("-j", "--json", action="store_true", help="JSON 输出") parser.add_argument("-v", "--version", action="version", version=f"%(prog)s v{VERSION}") args = parser.parse_args() raw_preset = args.preset or "写实摄影" primary_raw, secondary_raw = parse_mix_preset(raw_preset) if secondary_raw: primary_resolved = resolve_preset(primary_raw) secondary_resolved = resolve_preset(secondary_raw) if not primary_resolved or not secondary_resolved: print(f"❌ 未知预设：{primary_raw} 或 {secondary_raw}", file=sys.stderr) sys.exit(1) preset, mix_secondary = primary_resolved, secondary_resolved else: preset, mix_secondary = primary_raw, None auto = parse_requirement(args.subject) aspect = args.aspect or auto["aspect_suggestion"] or STYLE_PRESETS.get(resolve_preset(preset) or "写实摄影", {}).get("aspect", "1:1") recipe = build_prompt( args.subject, preset, args.model, aspect, extra_negatives=args.avoid, seed=args.seed, quality_tier=args.tier, mix_secondary=mix_secondary, mix_ratio=args.mix, ) seed = recipe["seed_suggestion"] if args.backend == "none": out = {"version": VERSION, "backend": "none", "recipe": recipe, "note": "dry-run，未实际调用模型"} if args.json: print(json.dumps(out, ensure_ascii=False, indent=2)) else: print(f"🧪 dry-run（未出图）") print(f" positive: {recipe['positive'][:200]}...") print(f" seed: {seed}") print(f" → 用 -j 输出完整 recipe，再 pipe 给 ComfyUI / DALL-E / SD WebUI") return try: if args.backend == "sd-webui": result = render_sdwebui( recipe["positive"], recipe["negative"], aspect, seed, args.steps, args.cfg, args.sampler, args.output, ) elif args.backend == "comfyui": result = render_comfyui( recipe["positive"], recipe["negative"], aspect, seed, args.steps, args.cfg, args.workflow or None, args.output, ) elif args.backend in ("dalle", "openai"): size = args.size or DALLE_SIZES.get(aspect, "1024x1024") result = render_dalle(recipe["positive"], size, args.output, n=args.n) elif args.backend == "replicate": model_ref = args.remote_model or "black-forest-labs/flux-schnell" result = render_replicate( recipe["positive"], recipe["negative"], aspect, seed, model_ref, args.output, steps=args.steps, cfg=args.cfg, ) elif args.backend == "fal": model_ref = args.remote_model or "fal-ai/flux/schnell" result = render_fal( recipe["positive"], recipe["negative"], aspect, seed, model_ref, args.output, steps=args.steps, ) elif args.backend == "jimeng": result = render_jimeng(recipe["positive"], recipe["negative"], aspect, seed, args.output) elif args.backend == "kling": result = render_kling(recipe["positive"], recipe["negative"], aspect, seed, args.output) elif args.backend in ("hailuo", "minimax"): result = render_hailuo(recipe["positive"], recipe["negative"], aspect, seed, args.output) else: raise RuntimeError(f"未知 backend: {args.backend}") except Exception as e: print(f"❌ 渲染失败: {e}", file=sys.stderr) sys.exit(2) out = {"version": VERSION, "recipe": recipe, "render": result} if args.json: print(json.dumps(out, ensure_ascii=False, indent=2)) else: print(f"✅ 已出图（backend={result['backend']}）") for p in result.get("saved", []): print(f" 📷 {p}") print(f" 🎲 seed = {seed}") if __name__ == "__main__": main() FILE:scripts/reverse_prompt.py #!/usr/bin/env python3 """ huo15-img-prompt — 参考图反解 v2.2 把现成图片（本地路径或 URL）反向解析成可复用的 T2I 提示词。工作流（三层）： 1. PNG metadata 提取：A1111 / ComfyUI / NovelAI 出图都把 prompt 写在 PNG `parameters` / `prompt` / `Comment` 字段 2. EXIF 提取：iPhone / 单反相机参数（焦距 / ISO / 快门 / 光圈），用于推断 camera 锁 3. VLM 模板生成：当 1/2 都没有可用信息时，输出标准化「请把这张图描述成 T2I 提示词」prompt 模板，交给 GPT-4o / Claude / Gemini 1.5 / Qwen-VL 等多模态模型继续解析输出三选一： - text 人类可读 - json 结构化（直接喂回 enhance_prompt.py） - mj Midjourney 风格直接复用 prompt（含 --ar / --sref / --seed）调用： reverse_prompt.py /path/to/image.png reverse_prompt.py https://example.com/img.png --vlm reverse_prompt.py img.png -j > recipe.json && enhance_prompt.py "$(jq -r .subject recipe.json)" """ import sys import os import json import re import argparse import struct from typing import Dict, List, Optional, Tuple from urllib.parse import urlparse from urllib.request import Request, urlopen VERSION = "3.1.0" # ───────────────────────────────────────────────────────── # PNG metadata 解析 # ───────────────────────────────────────────────────────── PNG_TEXT_KEYS_A1111 = ("parameters",) PNG_TEXT_KEYS_COMFY = ("prompt", "workflow") PNG_TEXT_KEYS_NOVELAI = ("Description", "Comment", "Software") def read_png_text_chunks(blob: bytes) -> Dict[str, str]: """手写 PNG 解析，避免 PIL 依赖。提取 tEXt / iTXt / zTXt 文本块。""" if not blob.startswith(b"\x89PNG\r\n\x1a\n"): return {} out: Dict[str, str] = {} i = 8 while i < len(blob): if i + 8 > len(blob): break length = struct.unpack(">I", blob[i:i+4])[0] ctype = blob[i+4:i+8] data = blob[i+8:i+8+length] i += 8 + length + 4 # skip CRC if ctype == b"tEXt": try: key, value = data.split(b"\x00", 1) out[key.decode("latin-1", "replace")] = value.decode("utf-8", "replace") except ValueError: continue elif ctype == b"iTXt": try: key, rest = data.split(b"\x00", 1) # iTXt: key\0 compress_flag(1) compress_method(1) lang_tag\0 trans_keyword\0 text if len(rest) < 2: continue _flag, _method = rest[0], rest[1] rest2 = rest[2:] _lang, rest3 = rest2.split(b"\x00", 1) _trans, text = rest3.split(b"\x00", 1) out[key.decode("latin-1", "replace")] = text.decode("utf-8", "replace") except (ValueError, IndexError): continue elif ctype == b"IEND": break return out def parse_a1111_params(text: str) -> Dict[str, str]: """解析 AUTOMATIC1111 / ForgeUI 的 parameters 文本。格式： positive_prompt Negative prompt: ... Steps: 30, Sampler: ..., CFG scale: ..., Seed: ..., Size: ..., Model: ... """ out: Dict[str, str] = {} if "Negative prompt:" in text: pos, rest = text.split("Negative prompt:", 1) out["positive"] = pos.strip() if "\n" in rest: neg, params = rest.split("\n", 1) out["negative"] = neg.strip() else: params = "" out["negative"] = rest.strip() else: if "\n" in text and re.search(r"^\w+:", text.strip().split("\n")[-1]): lines = text.strip().split("\n") out["positive"] = "\n".join(lines[:-1]).strip() params = lines[-1] else: out["positive"] = text.strip() params = "" for kv in re.findall(r"([A-Za-z][\w\s]*?):\s*([^,]+)", params): k, v = kv[0].strip().lower().replace(" ", "_"), kv[1].strip() out[k] = v return out def detect_source(meta: Dict[str, str]) -> str: if "parameters" in meta: return "a1111" if "prompt" in meta and "workflow" in meta: return "comfyui" if any(k in meta for k in ("Description", "Software")) and "Comment" in meta: return "novelai" if any("Stable Diffusion" in str(v) for v in meta.values()): return "sd-generic" return "unknown" # ───────────────────────────────────────────────────────── # 启发式：从 prompt 文本推断风格预设 # ───────────────────────────────────────────────────────── PRESET_HEURISTICS: List[Tuple[str, str]] = [ (r"\b(cyberpunk|neon|blade runner|holographic)\b", "赛博朋克"), (r"\b(steampunk|brass|gears)\b", "蒸汽朋克"), (r"\b(ghibli|miyazaki|studio ghibli)\b", "宫崎骏"), (r"\b(makoto shinkai|shinkai)\b", "新海诚"), (r"\b(genshin|mihoyo|honkai)\b", "原神"), (r"\b(dunhuang|tang dynasty fresco|apsara)\b", "敦煌壁画"), (r"\b(hanfu)\b", "汉服写真"), (r"\b(ink wash|sumi-e|chinese ink)\b", "水墨"), (r"\b(ukiyo-e|woodblock)\b", "浮世绘"), (r"\b(glassmorphism|frosted glass)\b", "玻璃拟态"), (r"\b(neumorphism|soft ui)\b", "新拟态"), (r"\b(bauhaus)\b", "包豪斯"), (r"\b(brutalism|brutalist concrete)\b", "粗野主义"), (r"\b(wabi[\s-]?sabi)\b", "侘寂"), (r"\b(film grain|kodak|portra|analog film)\b", "胶片摄影"), (r"\b(black and white|monochrome|silver gelatin)\b", "黑白摄影"), (r"\b(low poly|lowpoly)\b", "低多边形"), (r"\b(isometric)\b", "等距视图"), (r"\b(claymation|clay)\b", "粘土"), (r"\b(impressionist|monet|renoir)\b", "印象派"), (r"\b(van gogh|post impressionist)\b", "后印象派"), (r"\b(art deco|gatsby)\b", "装饰艺术"), (r"\b(art nouveau|mucha)\b", "新艺术"), (r"\b(vaporwave|y2k)\b", "Vaporwave"), (r"\b(anime|cel shaded|cel-shaded)\b", "动漫"), (r"\b(watercolor)\b", "水彩"), (r"\b(oil painting)\b", "油画"), (r"\b(pixel art|8[\s-]?bit|16[\s-]?bit)\b", "像素艺术"), (r"\b(minimalist|minimal)\b", "极简主义"), (r"\b(cinematic|imax|35mm)\b", "电影感"), (r"\b(concept art)\b", "概念艺术"), (r"\b(dark fantasy)\b", "黑暗奇幻"), (r"\b(fantasy|epic fantasy)\b", "奇幻"), (r"\b(sci[\s-]?fi|space opera)\b", "科幻"), ] def guess_preset(positive: str) -> str: p = positive.lower() for pattern, preset in PRESET_HEURISTICS: if re.search(pattern, p): return preset return "" def guess_aspect(size_str: str) -> str: if not size_str or "x" not in size_str.lower(): return "" try: w, h = [int(x) for x in re.findall(r"\d+", size_str)[:2]] except (ValueError, IndexError): return "" ratio = w / h if h else 1 candidates = [ ("1:1", 1.0), ("16:9", 16/9), ("9:16", 9/16), ("3:4", 3/4), ("4:3", 4/3), ("21:9", 21/9), ("3:2", 3/2), ("2:3", 2/3), ] return min(candidates, key=lambda c: abs(ratio - c[1]))[0] # ───────────────────────────────────────────────────────── # VLM 模板（图片无 metadata 时，让多模态模型回填） # ───────────────────────────────────────────────────────── VLM_TEMPLATE = """请把这张图反向解析成可复现的 Text-to-Image 提示词，输出严格的 JSON： { "subject": "图中主体的中文一句话描述（人/物/场景核心）", "subject_en": "subject in English", "style_preset": "从这 88 个预设里选一个最贴近的：写实摄影 / 胶片摄影 / 黑白摄影 / 人像摄影 / 时尚大片 / 美食摄影 / 产品摄影 / 微距摄影 / 航拍摄影 / 街拍纪实 / 暗黑美食 / 日杂 / 街头潮流 / 动漫 / 新海诚 / 宫崎骏 / 美漫 / Q版 / 童话绘本 / 萌系 / 厚涂 / 轻小说封面 / 赛璐璐 / 水彩 / 油画 / 水墨 / 工笔国画 / 浮世绘 / 线稿 / 像素艺术 / 3DC4D / 盲盒手办 / 低多边形 / 等距视图 / 粘土 / 毛毡手工 / 纸艺 / 极简主义 / 平面设计 / Logo设计 / 图标设计 / 信息图 / 品牌KV / 专辑封面 / 复古海报 / 电影海报 / 表情包 / 玻璃拟态 / 新拟态 / 孟菲斯 / 杂志编排 / 包豪斯 / 奶油风 / 印象派 / 后印象派 / 新艺术 / 装饰艺术 / 赛博朋克 / 蒸汽朋克 / 科幻 / 奇幻 / 黑暗奇幻 / 国潮 / Y2K / Vaporwave / 霓虹灯牌 / 建筑可视化 / 电影感 / 概念艺术 / 粗野主义 / 北欧极简 / 侘寂 / 疗愈治愈 / 美式复古 / 原神 / 崩铁星穹 / 英雄联盟 / 暗黑4 / Valorant / Pokemon / 暴雪风 / 敦煌壁画 / 青花瓷 / 民国月份牌 / 年画 / 剪纸 / 和风 / 汉服写真", "aspect": "1:1 / 3:4 / 16:9 / 21:9 / 9:16", "camera": "镜头/视角/焦段，例：'85mm telephoto, low angle, shallow depth of field'", "lighting": "光影描述，例：'golden hour rim light, soft fill'", "palette": "主色板，例：'muted earth tones, sage green and terracotta'", "composition": "构图特征：特写/近景/中景/全身/俯拍/仰拍/航拍/侧面/背面", "mood": "情绪：温暖/冷峻/神秘/梦幻/欢快/史诗/治愈/紧张", "time_of_day": "清晨/黄昏/日落/深夜/蓝调时刻等（无则填空）", "weather": "晴/雨/雾/雪等（无则填空）", "season": "春/夏/秋/冬/樱花季/枫叶季（无则填空）", "key_details": ["关键视觉元素 1", "元素 2", "元素 3"], "negatives": ["应避免出现的事物（用于负面提示）"], "suggested_prompt": "完整可直接喂给 Midjourney 的英文提示词（不含 --ar 参数）" } 只输出 JSON，不要解释。 """ # ───────────────────────────────────────────────────────── # IO # ───────────────────────────────────────────────────────── def load_image_bytes(src: str) -> bytes: if src.startswith(("http://", "https://")): req = Request(src, headers={"User-Agent": "huo15-reverse/1.0"}) with urlopen(req, timeout=15) as r: return r.read() with open(os.path.expanduser(src), "rb") as f: return f.read() # ───────────────────────────────────────────────────────── # 主反解流程 # ───────────────────────────────────────────────────────── def reverse(src: str, vlm: bool = False) -> Dict: blob = load_image_bytes(src) is_png = blob.startswith(b"\x89PNG\r\n\x1a\n") meta = read_png_text_chunks(blob) if is_png else {} source = detect_source(meta) parsed: Dict[str, str] = {} if source == "a1111": parsed = parse_a1111_params(meta.get("parameters", "")) elif source == "comfyui": parsed = {"comfy_workflow": meta.get("workflow", "")[:200] + "...", "raw_prompt_json": meta.get("prompt", "")[:500]} try: data = json.loads(meta.get("prompt", "{}")) for node_id, node in data.items(): if isinstance(node, dict) and node.get("class_type") in ("CLIPTextEncode", "CLIPTextEncodeSDXL"): txt = (node.get("inputs") or {}).get("text", "") if txt: if "positive" not in parsed: parsed["positive"] = txt elif "negative" not in parsed: parsed["negative"] = txt except (json.JSONDecodeError, AttributeError): pass elif source == "novelai": parsed = { "positive": meta.get("Description", ""), "comment": meta.get("Comment", "")[:500], } positive = parsed.get("positive", "") suggested_preset = guess_preset(positive) if positive else "" suggested_aspect = guess_aspect(parsed.get("size", "")) out: Dict = { "version": VERSION, "source": source, "file_size_bytes": len(blob), "is_png": is_png, "raw_metadata_keys": list(meta.keys()), "parsed": parsed, "suggested": { "preset": suggested_preset, "aspect": suggested_aspect, "seed": parsed.get("seed", ""), "model": parsed.get("model", ""), "sampler": parsed.get("sampler", ""), "cfg": parsed.get("cfg_scale", ""), "steps": parsed.get("steps", ""), }, } if vlm or source in ("unknown", ""): out["vlm_template"] = VLM_TEMPLATE out["vlm_instructions"] = ( "图中没有可读 metadata 或 metadata 不完整。请把图 + 上面 vlm_template 一起发给" " GPT-4o / Claude Sonnet 4.6 / Gemini 1.5 Pro / Qwen-VL，得到结构化 JSON 后，" "用 enhance_prompt.py \"\" -p \"\" -a \"\" 复现。" ) return out def to_mj_prompt(result: Dict) -> str: p = result.get("parsed", {}) pos = p.get("positive", "") aspect = result.get("suggested", {}).get("aspect", "") seed = result.get("suggested", {}).get("seed", "") flags = [] if aspect: flags.append(f"--ar {aspect}") if seed: flags.append(f"--seed {seed}") flags.append("--stylize 250") return f"{pos} {' '.join(flags)}".strip() def print_result(r: Dict): sep = "═" * 60 print(f"\n{sep}") print(f"🔍 参考图反解 v{r['version']}") print(f"📁 文件大小 : {r['file_size_bytes']:,} bytes") print(f"🏷 来源识别 : {r['source']}") print(f"🗂 metadata 字段: {', '.join(r['raw_metadata_keys']) or '(无)'}") p = r.get("parsed", {}) if p.get("positive"): print(f"\n✅ 反解正向提示：\n{p['positive']}") if p.get("negative"): print(f"\n❌ 反解负向提示：\n{p['negative']}") s = r.get("suggested", {}) if any(s.values()): print(f"\n💡 推荐参数：") for k, v in s.items(): if v: print(f" {k:8s}: {v}") if r.get("vlm_template"): print(f"\n🤖 VLM 模板（图无 metadata 时使用）：") print(r.get("vlm_instructions", "")) print("\n--- 模板开始 ---") print(r["vlm_template"]) print("--- 模板结束 ---") print(f"{sep}\n") def main(): parser = argparse.ArgumentParser( description=f"huo15-img-prompt reverse_prompt v{VERSION} — 参考图反解", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=""" 示例: reverse_prompt.py /path/to/image.png # 自动识别 A1111/ComfyUI/NovelAI metadata reverse_prompt.py https://example.com/img.png # 远程 URL reverse_prompt.py img.png --vlm # 强制输出 VLM 模板（图无 metadata） reverse_prompt.py img.png --mj # 直接给出 Midjourney 复用 prompt reverse_prompt.py img.png -j # JSON 输出，可 pipe 给 enhance_prompt.py """, ) parser.add_argument("source", help="图片本地路径或 URL") parser.add_argument("--vlm", action="store_true", help="无论 metadata 是否齐全，都输出 VLM 模板") parser.add_argument("--mj", action="store_true", help="只输出 Midjourney 风格 prompt 一行") parser.add_argument("-j", "--json", action="store_true", help="JSON 输出") parser.add_argument("-v", "--version", action="version", version=f"%(prog)s v{VERSION}") args = parser.parse_args() try: r = reverse(args.source, vlm=args.vlm) except FileNotFoundError: print(f"❌ 找不到文件: {args.source}", file=sys.stderr) sys.exit(1) except Exception as e: print(f"❌ 加载失败: {e}", file=sys.stderr) sys.exit(1) if args.mj: print(to_mj_prompt(r)) return if args.json: print(json.dumps(r, ensure_ascii=False, indent=2)) return print_result(r) if __name__ == "__main__": main() FILE:scripts/safety_lint.py #!/usr/bin/env python3 """ huo15-img-prompt — 平台合规润色 v2.3 把"会被 SD/MJ/DALL-E 误判但本意是合法艺术创作"的描述，做艺术化重写，提高过审率。**不是 jailbreak**，不做也拒绝以下场景： ✗ CSAM（任何含未成年 + 性化描述的） ✗ 真人 + 色情/裸露 ✗ 真人 + 政治污蔑/诽谤 ✗ 制作武器、毒品、爆炸物的具体方法 ✗ 自残、自杀的诱导画面 ✗ 仇恨/种族歧视画面 ✓ 历史/神话/魔幻战斗（"血" → crimson splash） ✓ 古典艺术裸体（"裸" → classical nude figure study, art reference） ✓ 黑暗童话/惊悚氛围（"恐怖" → eerie atmospheric tension） ✓ 赛博朋克义体/机甲伤痕（"伤" → battle-scarred armor texture） ✓ 医学/解剖艺术插画工作流程： 1. 红线检测：扫描禁区词组合，命中即拒 2. 黄区识别：标识可能误判的词 3. 艺术替代：内置 80+ 艺术化重写词典 4. 平台分级：DALL-E 最严 / MJ 中等 / SD 宽松（开源），分别给出建议调用： safety_lint.py "战士手中沾满鲜血的剑" safety_lint.py "古典维纳斯雕像" --target dalle safety_lint.py "赛博朋克战斗场景" -j """ import sys import os import json import re import argparse from typing import Dict, List, Tuple VERSION = "3.1.0" # ───────────────────────────────────────────────────────── # 红线（直接拒答） # ───────────────────────────────────────────────────────── HARD_BLOCKS: List[Tuple[str, str]] = [ # 未成年 + 性化（任意组合都拒） (r"(loli|lolita|underage|child|minor|kid|toddler|baby|teen|teenager|13岁|14岁|15岁|16岁|17岁|未成年|幼女|小学生|初中生|学生)\s*.*(nude|naked|sex|nsfw|porn|裸|性|色情|nipple|breast)", "minor + sexual"), (r"(nude|naked|sex|nsfw|porn|裸|性|色情)\s*.*(loli|underage|child|minor|kid|toddler|baby|teen|未成年|幼女|小学生|初中生)", "minor + sexual"), # 真人 + 色情（指名道姓） (r"(taylor swift|emma watson|scarlett johansson|某某明星|周杰伦|王力宏)\s*.*(nude|naked|sex|porn|裸|色情)", "real-person + sexual"), # 武器制造、毒品、爆炸物配方（双向：动词在前 OR 在后） (r"(how to make|recipe for|tutorial|step.*by.*step|步骤|配方|怎么做|如何制作|教程)\s*.*(bomb|explosive|gun|firearm|meth|cocaine|heroin|fentanyl|nitroglycerin|炸弹|手枪|冰毒|海洛因|芬太尼|硝酸|tnt)", "weapon/drug instruction"), (r"(bomb|explosive|gun|firearm|meth|cocaine|heroin|fentanyl|炸弹|手枪|冰毒|海洛因|芬太尼)\s*.*(how to make|recipe|tutorial|步骤|配方|怎么做|如何制作|教程|方法)", "weapon/drug instruction"), # 自残诱导（双向） (r"(suicide|self-harm|cutting|自杀|自残|割腕|跳楼)\s*.*(method|how to|tutorial|教程|方法|步骤)", "self-harm method"), (r"(method|how to|tutorial|教程|方法|步骤)\s*.*(suicide|self-harm|cutting|自杀|自残|割腕|跳楼)", "self-harm method"), ] # ───────────────────────────────────────────────────────── # 黄区：会被误判但通常合法的艺术词 → 艺术化替代 # ───────────────────────────────────────────────────────── ART_SUBSTITUTIONS: Dict[str, Dict[str, str]] = { # 战斗 / 暴力（合法艺术语境） "blood": {"replace": "crimson splash, dramatic battle highlight", "category": "violence", "platforms": "DALL-E,MJ"}, "鲜血": {"replace": "crimson splash, 朱砂色泼洒", "category": "violence", "platforms": "DALL-E,MJ"}, "血": {"replace": "crimson splash", "category": "violence", "platforms": "DALL-E"}, "wound": {"replace": "battle-scarred texture", "category": "violence", "platforms": "DALL-E"}, "伤口": {"replace": "battle-scarred texture, 战痕", "category": "violence", "platforms": "DALL-E"}, "kill": {"replace": "defeat, vanquish", "category": "violence", "platforms": "DALL-E,MJ"}, "杀": {"replace": "vanquish, 击败", "category": "violence", "platforms": "DALL-E,MJ"}, "murder": {"replace": "dramatic confrontation", "category": "violence", "platforms": "DALL-E,MJ"}, "weapon": {"replace": "ceremonial blade, ornamental armament", "category": "violence", "platforms": "DALL-E"}, "gun": {"replace": "fantasy ranged weapon, prop firearm", "category": "violence", "platforms": "DALL-E"}, "knife": {"replace": "ornamental dagger, ritual blade", "category": "violence", "platforms": "DALL-E"}, "violence": {"replace": "dynamic combat, cinematic action", "category": "violence", "platforms": "DALL-E,MJ"}, "暴力": {"replace": "dynamic combat scene, 动作张力", "category": "violence", "platforms": "DALL-E,MJ"}, # 古典艺术裸体 "naked": {"replace": "classical nude figure study, art reference, marble sculpture style", "category": "nudity", "platforms": "DALL-E,MJ,SD"}, "nude": {"replace": "classical figure study, fine art reference", "category": "nudity", "platforms": "DALL-E,MJ"}, "裸": {"replace": "classical figure study, 古典裸体艺术", "category": "nudity", "platforms": "DALL-E,MJ,SD"}, "裸体": {"replace": "classical figure study, 古典维纳斯", "category": "nudity", "platforms": "DALL-E,MJ,SD"}, "sexy": {"replace": "elegant alluring, fashion editorial", "category": "nudity", "platforms": "DALL-E"}, "性感": {"replace": "elegant fashion editorial, 优雅造型", "category": "nudity", "platforms": "DALL-E"}, "lingerie": {"replace": "vintage fashion sleepwear, 1950s glamour", "category": "nudity", "platforms": "DALL-E"}, "bikini": {"replace": "summer beachwear, swimwear photography", "category": "nudity", "platforms": "DALL-E"}, # 恐怖 / 黑暗 "horror": {"replace": "eerie atmospheric tension, gothic mood", "category": "horror", "platforms": "DALL-E"}, "恐怖": {"replace": "gothic atmospheric tension, 哥特氛围", "category": "horror", "platforms": "DALL-E"}, "scary": {"replace": "ominous mood, atmospheric suspense", "category": "horror", "platforms": "DALL-E"}, "gore": {"replace": "dark fantasy aesthetic, baroque dramatic", "category": "horror", "platforms": "DALL-E,MJ"}, "monster": {"replace": "mythical creature, fantasy beast", "category": "horror", "platforms": "DALL-E"}, "demon": {"replace": "mythical entity, dark fantasy spirit", "category": "horror", "platforms": "DALL-E"}, "evil": {"replace": "dark mythological aesthetic, 黑暗神话", "category": "horror", "platforms": "DALL-E"}, # 死亡 / 尸体（艺术语境） "dead": {"replace": "fallen, resting eternal", "category": "death", "platforms": "DALL-E"}, "death": {"replace": "memento mori, classical allegory", "category": "death", "platforms": "DALL-E"}, "corpse": {"replace": "still figure, classical allegorical pose", "category": "death", "platforms": "DALL-E"}, "skeleton": {"replace": "anatomical skeletal study, da vinci sketch reference", "category": "death", "platforms": "DALL-E"}, "skull": {"replace": "memento mori symbol, vanitas still life", "category": "death", "platforms": "DALL-E"}, # 真人 "celebrity": {"replace": "fictional character inspired by 80s aesthetic", "category": "real-person", "platforms": "DALL-E,MJ"}, "明星": {"replace": "虚构角色，80年代美学风格", "category": "real-person", "platforms": "DALL-E,MJ"}, "actor": {"replace": "fictional protagonist, original character", "category": "real-person", "platforms": "DALL-E"}, "politician": {"replace": "fictional statesman character", "category": "real-person", "platforms": "DALL-E,MJ"}, # 品牌（版权） "marvel": {"replace": "superhero comic style", "category": "brand", "platforms": "DALL-E"}, "disney": {"replace": "classic animated film style", "category": "brand", "platforms": "DALL-E"}, "nike": {"replace": "athletic sportswear brand aesthetic", "category": "brand", "platforms": "DALL-E"}, "iphone": {"replace": "modern smartphone, sleek minimal device", "category": "brand", "platforms": "DALL-E"}, # 武器具体型号 "ak47": {"replace": "fictional assault rifle prop", "category": "weapon-model", "platforms": "DALL-E,MJ"}, "ak-47": {"replace": "fictional assault rifle prop", "category": "weapon-model", "platforms": "DALL-E,MJ"}, "glock": {"replace": "sci-fi handgun prop", "category": "weapon-model", "platforms": "DALL-E,MJ"}, "uzi": {"replace": "compact fictional firearm prop", "category": "weapon-model", "platforms": "DALL-E,MJ"}, } # 平台分级规则 PLATFORM_STRICTNESS = { "dalle": "max", # 最严 "DALL-E": "max", "midjourney": "high", # 中等 "MJ": "high", "mj": "high", "sd": "low", # 宽松（本地） "SD": "low", "sdxl": "low", "flux": "low", "comfyui": "low", } # 风险等级 → 颜色 emoji RISK_LEVEL_EMOJI = {"high": "🔴", "medium": "🟡", "low": "🟢"} def category_risk_for_platform(category: str, platform: str) -> str: s = PLATFORM_STRICTNESS.get(platform, "high") risk_map = { "violence": {"max": "high", "high": "medium", "low": "low"}, "nudity": {"max": "high", "high": "high", "low": "medium"}, "horror": {"max": "medium", "high": "low", "low": "low"}, "death": {"max": "medium", "high": "low", "low": "low"}, "real-person": {"max": "high", "high": "high", "low": "medium"}, "brand": {"max": "high", "high": "medium", "low": "low"}, "weapon-model": {"max": "high", "high": "high", "low": "medium"}, } return risk_map.get(category, {}).get(s, "low") # ───────────────────────────────────────────────────────── # 检测 # ───────────────────────────────────────────────────────── def check_hard_blocks(text: str) -> List[str]: """返回命中的红线类别（命中任何一个即拒答）。""" hits = [] lower = text.lower() for pattern, label in HARD_BLOCKS: if re.search(pattern, lower, re.IGNORECASE): hits.append(label) return hits def find_substitutions(text: str, platform: str = "MJ") -> List[Dict]: """识别文本中的黄区词，返回替代建议列表。""" out = [] lower = text.lower() seen = set() for word, info in ART_SUBSTITUTIONS.items(): if word in seen: continue # 中文词直接子串匹配，英文词加单词边界 if re.fullmatch(r"[\x00-\x7f]+", word): # ASCII if not re.search(r"\b" + re.escape(word.lower()) + r"\b", lower): continue else: if word not in text: continue seen.add(word) risk = category_risk_for_platform(info["category"], platform) out.append({ "word": word, "replace_with": info["replace"], "category": info["category"], "risk_for_platform": risk, "platforms_affected": info["platforms"], }) return out def rewrite(text: str, platform: str = "MJ") -> Tuple[str, List[Dict]]: """执行重写：把所有黄区词替换成艺术化版本。返回 (新文本, 替换日志)。""" new_text = text log = [] for word, info in ART_SUBSTITUTIONS.items(): if re.fullmatch(r"[\x00-\x7f]+", word): pat = re.compile(r"\b" + re.escape(word) + r"\b", re.IGNORECASE) else: pat = re.compile(re.escape(word)) if pat.search(new_text): risk = category_risk_for_platform(info["category"], platform) new_text = pat.sub(info["replace"], new_text) log.append({"from": word, "to": info["replace"], "category": info["category"], "risk_for_platform": risk}) return new_text, log # ───────────────────────────────────────────────────────── # 入口 # ───────────────────────────────────────────────────────── def lint(text: str, platform: str = "MJ") -> Dict: blocks = check_hard_blocks(text) if blocks: return { "version": VERSION, "platform": platform, "verdict": "REJECT", "reason": "hit hard-block patterns", "categories": blocks, "advice": ( "命中红线规则。本工具不服务以下场景：\n" " • CSAM（任何含未成年 + 性化）\n" " • 真人 + 色情 / 政治污蔑\n" " • 武器/毒品/爆炸物制作教程\n" " • 自残/自杀方法诱导\n" "如果你的本意是合法艺术创作（历史/神话/古典），请改写描述：\n" " • 用成年角色\n" " • 用艺术语境（古典雕塑/神话/壁画）\n" " • 不要点名真人\n" " • 不要含「教程/步骤/方法」等指令性词" ), } subs = find_substitutions(text, platform) rewritten, log = rewrite(text, platform) return { "version": VERSION, "platform": platform, "verdict": "OK" if not subs else "REWRITE", "original": text, "rewritten": rewritten, "substitutions": subs, "rewrite_log": log, "high_risk_count": sum(1 for s in subs if s["risk_for_platform"] == "high"), "medium_risk_count": sum(1 for s in subs if s["risk_for_platform"] == "medium"), "advice": _build_advice(platform, subs), } def _build_advice(platform: str, subs: List[Dict]) -> str: if not subs: return f"无风险词，可直接喂给 {platform}。" lines = [f"针对 {platform}（严格度: {PLATFORM_STRICTNESS.get(platform, 'high')}）的合规建议："] high = [s for s in subs if s["risk_for_platform"] == "high"] if high: lines.append(f" 🔴 {len(high)} 个高风险词建议必换：" + ", ".join(s["word"] for s in high)) med = [s for s in subs if s["risk_for_platform"] == "medium"] if med: lines.append(f" 🟡 {len(med)} 个中风险词建议软化：" + ", ".join(s["word"] for s in med)) return "\n".join(lines) def print_lint(r: Dict): sep = "═" * 60 print(f"\n{sep}") print(f"🛡 平台合规润色 v{r['version']}") print(f"📺 目标平台: {r['platform']} (严格度: {PLATFORM_STRICTNESS.get(r['platform'], '?')})") if r["verdict"] == "REJECT": print(f"\n🚫 拒答: {r['reason']}") print(f" 命中类别: {', '.join(r['categories'])}") print(f"\n{r['advice']}") print(f"{sep}\n") return print(f"📝 原文: {r['original']}") if r["verdict"] == "OK": print(f"\n✅ 无风险词，原文可直接使用") print(f"{sep}\n") return print(f"\n✨ 重写后: {r['rewritten']}") print(f"\n📊 风险统计: 🔴 {r['high_risk_count']} / 🟡 {r['medium_risk_count']}") if r["substitutions"]: print(f"\n🔄 替换详情:") for s in r["substitutions"]: emoji = RISK_LEVEL_EMOJI.get(s["risk_for_platform"], "⚪") print(f" {emoji} '{s['word']}' → '{s['replace_with']}'") print(f" 类别: {s['category']}, 平台: {s['platforms_affected']}") print(f"\n💡 {r['advice']}") print(f"{sep}\n") def main(): parser = argparse.ArgumentParser( description=f"huo15-img-prompt safety_lint v{VERSION} — 平台合规润色（合法艺术创作专用）", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=""" 示例: safety_lint.py "战士手中沾满鲜血的剑" safety_lint.py "古典维纳斯雕像" --target dalle safety_lint.py "赛博朋克战斗场景" --target SD safety_lint.py "黑暗骑士" -j echo "原始描述" | safety_lint.py --stdin --apply # 重写并输出新文本注意: 本工具仅服务合法艺术创作。拒绝以下场景： ✗ CSAM（未成年 + 性化） ✗ 真人 + 色情/诽谤 ✗ 武器/毒品/爆炸物制作教程 ✗ 自残诱导 """, ) parser.add_argument("text", nargs="?", help="要检查的文本") parser.add_argument("--stdin", action="store_true", help="从 stdin 读取") parser.add_argument("--target", default="MJ", help="目标平台 DALL-E/MJ/SD/SDXL/Flux/通用 (默认 MJ)") parser.add_argument("--apply", action="store_true", help="直接输出重写后的文本（用于 pipe）") parser.add_argument("-j", "--json", action="store_true", help="JSON 输出") parser.add_argument("-v", "--version", action="version", version=f"%(prog)s v{VERSION}") args = parser.parse_args() text = args.text if args.stdin or not text: if sys.stdin.isatty() and not args.stdin: parser.print_help() sys.exit(1) text = sys.stdin.read().strip() if not text: print("❌ 输入为空", file=sys.stderr) sys.exit(1) r = lint(text, args.target) if args.apply: if r["verdict"] == "REJECT": print(f"REJECTED: {r['reason']}", file=sys.stderr) sys.exit(2) print(r.get("rewritten", r["original"])) return if args.json: print(json.dumps(r, ensure_ascii=False, indent=2)) return print_lint(r) if r["verdict"] == "REJECT": sys.exit(2) if __name__ == "__main__": main() FILE:scripts/storyboard.py #!/usr/bin/env python3 """ huo15-img-prompt — 故事板模式 v3.0 把一段剧本/文案 → Claude 拆 N 个关键帧 → 每帧出 T2I prompt + 帧间 T2V 衔接 prompt → 产出完整视频脚本包（可直接喂给 Sora/Kling/Runway/即梦）。这是 v3.0 的杀手级 feature：把文生图 + 文生视频的"单点能力"组合成"短片生产管线"。视频内容创作者远多于静态图创作者。工作流（一次调用完成）： Step 1: Claude 读剧本 → 拆 N scenes，每个 scene 给主体描述/构图/光影/动作 Step 2: 对每个 scene，复用 enhance_prompt 生成 T2I 提示词 Step 3: 对每两个相邻 scene，复用 enhance_video 生成衔接 T2V 提示词 Step 4: 整合输出 storyboard.json + scenes/*.txt + README.md（可读视图）调用： storyboard.py "一只猫从城市走进雨夜" -p 电影感 --scenes 4 -m Sora storyboard.py < script.txt --scenes 8 storyboard.py "..." --scenes 5 --output ./my_story --video-model Kling storyboard.py "..." --scenes 6 -j > storyboard.json # JSON 输出依赖： - 同目录 enhance_prompt.py / enhance_video.py - ANTHROPIC_API_KEY """ import sys import os import json import argparse import time import re from typing import Dict, List, Optional from urllib.request import Request, urlopen from urllib.error import HTTPError sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) from enhance_prompt import ( build_prompt, parse_mix_preset, resolve_preset, STYLE_PRESETS, stable_seed, ) from enhance_video import build_video_prompt from claude_polish import ANTHROPIC_BASE, ANTHROPIC_VERSION VERSION = "3.1.0" DEFAULT_MODEL = "claude-sonnet-4-5" # ───────────────────────────────────────────────────────── # Claude 拆剧本 system prompt（启用 cache） # ───────────────────────────────────────────────────────── def build_storyboard_system_prompt(target_scenes: int) -> str: return f"""你是火一五故事板分镜师。给定一段剧本/文案，拆成 {target_scenes} 个关键帧（key frames），每帧用一句话主体描述 + 视觉/动作要素，相邻帧之间标注衔接动作。 # 工作流 1. 读剧本，提取叙事节奏（开场 → 起 → 承 → 转 → 合） 2. 拆成 {target_scenes} 个连贯关键帧 3. 每帧给： - 主体（人/物/场景核心，一句话中文） - 构图（特写/中景/全身/俯拍/航拍/侧面等） - 光影/氛围（黄昏/雨夜/霓虹/逆光等） - 主体动作/表情（用于 T2I） 4. 每相邻两帧之间给衔接动作（用于 T2V，描述镜头/主体怎么从 A 帧过渡到 B 帧） # 输出 JSON 严格 schema ```json {{ "title": "整段剧本的简短标题（5-10 字）", "logline": "一句话总结", "narrative_arc": "开场→起→承→转→合之类的节奏说明", "scenes": [ {{ "index": 1, "subject": "中文一句话主体描述（具体可视）", "subject_en": "English subject for T2I", "composition": "特写/中景/全身/俯拍/仰拍/航拍/侧面/背面之一", "lighting": "光影/时间/天气/氛围（中文）", "action": "主体动作/表情（用于 T2I 增强）", "narrative_role": "叙事角色（开场建立/冲突起点/高潮/落幕等）" }}, ...{target_scenes} 个 ], "transitions": [ {{ "from_scene": 1, "to_scene": 2, "camera_motion": "推镜/拉镜/摇镜/跟拍/手持/航拍等（中文）", "duration_s": 3, "description": "衔接动作描述（中文+英文混合，用于 T2V）" }}, ...{target_scenes - 1} 个 ], "total_duration_s": "估算总时长，秒" }} ``` # 关键 - {target_scenes} 个 scene，{target_scenes - 1} 个 transition - 每帧 subject 都要"画面感强"，让 T2I 能复现具体场景 - transitions 描述要让 T2V 模型知道镜头怎么动 + 主体怎么变化 - 全程中文为主，T2I 模型友好的视觉术语英文混合 - 只输出 JSON，不要解释""" def call_claude_storyboard(script: str, target_scenes: int, model: str = DEFAULT_MODEL) -> Dict: """调 Claude 拆剧本。""" api_key = os.environ.get("ANTHROPIC_API_KEY") if not api_key: raise RuntimeError("缺少 ANTHROPIC_API_KEY 环境变量") body = { "model": model, "max_tokens": 4096, "temperature": 0.7, "system": [{ "type": "text", "text": build_storyboard_system_prompt(target_scenes), "cache_control": {"type": "ephemeral"}, }], "messages": [ {"role": "user", "content": f"\n\n请输出 JSON。"}, {"role": "assistant", "content": "{"}, ], } req = Request( f"{ANTHROPIC_BASE}/v1/messages", data=json.dumps(body).encode("utf-8"), headers={ "Content-Type": "application/json", "x-api-key": api_key, "anthropic-version": ANTHROPIC_VERSION, }, method="POST", ) try: with urlopen(req, timeout=120) as r: resp = json.loads(r.read().decode("utf-8")) except HTTPError as e: raise RuntimeError(f"Claude HTTP {e.code}: {e.read().decode('utf-8', errors='replace')}") if "error" in resp: raise RuntimeError(f"Claude API 错误: {resp['error']}") text = "" for block in resp.get("content", []): if block.get("type") == "text": text += block.get("text", "") full = "{" + text # 抽完整 JSON depth = 0 end = -1 in_str = False esc = False for i, ch in enumerate(full): if esc: esc = False continue if ch == "\\": esc = True continue if ch == '"': in_str = not in_str continue if in_str: continue if ch == "{": depth += 1 elif ch == "}": depth -= 1 if depth == 0: end = i + 1 break if end == -1: raise RuntimeError(f"未找到完整 JSON: {full[:300]}") data = json.loads(full[:end]) usage = resp.get("usage", {}) data["_usage"] = { "input_tokens": usage.get("input_tokens", 0), "output_tokens": usage.get("output_tokens", 0), "cache_read_input_tokens": usage.get("cache_read_input_tokens", 0), } data["_model"] = resp.get("model", "") return data # ───────────────────────────────────────────────────────── # 整合：剧本 → scenes + transitions + T2I/T2V prompts # ───────────────────────────────────────────────────────── def storyboard(script: str, preset: str, target_scenes: int = 5, i2i_model: str = "通用", t2v_model: str = "通用", aspect: str = "", duration_per_transition: int = 3, quality_tier: str = "pro", claude_model: str = DEFAULT_MODEL) -> Dict: """主入口：剧本 → 完整 storyboard 包。""" # 1. Claude 拆剧本 primary, secondary = parse_mix_preset(preset) if secondary: p1, p2 = resolve_preset(primary), resolve_preset(secondary) if not p1 or not p2: raise RuntimeError(f"未知预设: {primary} 或 {secondary}") preset_resolved, mix_secondary = p1, p2 else: preset_resolved = resolve_preset(primary) or "电影感" mix_secondary = None if not aspect: aspect = STYLE_PRESETS[preset_resolved].get("aspect", "16:9") plan = call_claude_storyboard(script, target_scenes, model=claude_model) scenes_raw = plan.get("scenes", [])[:target_scenes] transitions_raw = plan.get("transitions", []) # 共享 seed 锁定整段一致性（角色/场景跨帧不漂移） base_seed = stable_seed(script[:80], preset_resolved) # 2. 每帧出 T2I prompt scene_prompts = [] for s in scenes_raw: subject = s.get("subject", "") action = s.get("action", "") composition = s.get("composition", "") lighting_atmos = s.get("lighting", "") full_subject = subject if action: full_subject = f"{full_subject}, {action}" if lighting_atmos: full_subject = f"{full_subject}, {lighting_atmos}" recipe = build_prompt( full_subject, preset_resolved, model=i2i_model, aspect=aspect, extra_composition=composition, seed=base_seed, quality_tier=quality_tier, mix_secondary=mix_secondary, ) scene_prompts.append({ "index": s.get("index"), "narrative_role": s.get("narrative_role", ""), "subject": subject, "subject_en": s.get("subject_en", ""), "composition": composition, "lighting_atmosphere": lighting_atmos, "action": action, "t2i_prompt": recipe["positive"], "t2i_negative": recipe["negative"], "consistency_lock": recipe["consistency_lock"], "seed": recipe["seed_suggestion"], }) # 3. 每对相邻帧出 T2V 衔接 prompt transition_prompts = [] for t in transitions_raw: from_idx = t.get("from_scene") to_idx = t.get("to_scene") if not from_idx or not to_idx: continue # 用 from-scene 的 subject 做基础，加 transition 描述 from_scene = next((s for s in scene_prompts if s["index"] == from_idx), None) to_scene = next((s for s in scene_prompts if s["index"] == to_idx), None) if not from_scene or not to_scene: continue transition_subject = ( f"transition from scene {from_idx} '{from_scene['subject']}' " f"to scene {to_idx} '{to_scene['subject']}': {t.get('description', '')}" ) camera_motion = t.get("camera_motion", "") video_recipe = build_video_prompt( transition_subject, preset_resolved, model=t2v_model, aspect=aspect, duration=t.get("duration_s", duration_per_transition), motion=camera_motion, seed=base_seed, quality_tier=quality_tier, mix_secondary=mix_secondary, ) transition_prompts.append({ "from_scene": from_idx, "to_scene": to_idx, "camera_motion": camera_motion, "duration_s": t.get("duration_s", duration_per_transition), "description": t.get("description", ""), "t2v_prompt": video_recipe["positive"], "t2v_negative": video_recipe["negative"], "keyframes": video_recipe.get("keyframes", []), }) return { "version": VERSION, "title": plan.get("title", ""), "logline": plan.get("logline", ""), "narrative_arc": plan.get("narrative_arc", ""), "preset": preset_resolved, "mix_secondary": mix_secondary, "aspect": aspect, "i2i_model": i2i_model, "t2v_model": t2v_model, "base_seed": base_seed, "total_scenes": len(scene_prompts), "total_transitions": len(transition_prompts), "estimated_duration_s": plan.get("total_duration_s") or sum(t["duration_s"] for t in transition_prompts) + 2 * len(scene_prompts), "scenes": scene_prompts, "transitions": transition_prompts, "_claude": plan.get("_usage", {}), } # ───────────────────────────────────────────────────────── # 输出 # ───────────────────────────────────────────────────────── def write_storyboard_files(result: Dict, output_dir: str) -> List[str]: """把 storyboard 写到多个文件。""" os.makedirs(output_dir, exist_ok=True) written = [] # 1. scenes.json p = os.path.join(output_dir, "storyboard.json") with open(p, "w", encoding="utf-8") as f: json.dump(result, f, ensure_ascii=False, indent=2) written.append(p) # 2. 每个 scene 的 t2i_prompt for s in result["scenes"]: idx = s["index"] p = os.path.join(output_dir, f"scene-{idx:02d}-t2i.txt") with open(p, "w", encoding="utf-8") as f: f.write(f"# Scene {idx}: {s['subject']}\n") f.write(f"# 角色: {s['narrative_role']}\n\n") f.write("## Positive\n") f.write(s["t2i_prompt"] + "\n\n") f.write("## Negative\n") f.write(s["t2i_negative"] + "\n") written.append(p) # 3. 每个 transition 的 t2v_prompt for t in result["transitions"]: p = os.path.join(output_dir, f"transition-{t['from_scene']:02d}-to-{t['to_scene']:02d}-t2v.txt") with open(p, "w", encoding="utf-8") as f: f.write(f"# Transition: scene {t['from_scene']} → {t['to_scene']}\n") f.write(f"# 镜头: {t['camera_motion']}\n") f.write(f"# 时长: {t['duration_s']}s\n\n") f.write("## Positive\n") f.write(t["t2v_prompt"] + "\n\n") f.write("## Negative\n") f.write(t["t2v_negative"] + "\n") written.append(p) # 4. README.md（可读总览） p = os.path.join(output_dir, "README.md") lines = [ f"# {result['title']}", "", f"> {result['logline']}", "", f"**叙事弧**: {result['narrative_arc']}", "", f"- 预设: {result['preset']}" + (f" + {result['mix_secondary']}" if result['mix_secondary'] else ""), f"- 画幅: {result['aspect']}", f"- 总场景: {result['total_scenes']} | 转场: {result['total_transitions']}", f"- 估算时长: {result['estimated_duration_s']} s", f"- I2I 模型: {result['i2i_model']} | T2V 模型: {result['t2v_model']}", f"- 锁定 seed: {result['base_seed']}", "", "## 场景", "", ] for s in result["scenes"]: lines.append(f"### Scene {s['index']}: {s['subject']}") lines.append("") lines.append(f"**角色**: {s['narrative_role']} | **构图**: {s['composition']} | **氛围**: {s['lighting_atmosphere']}") lines.append("") lines.append(f"📷 T2I prompt → 见 `scene-{s['index']:02d}-t2i.txt`") lines.append("") lines.append("## 转场") lines.append("") for t in result["transitions"]: lines.append(f"### Scene {t['from_scene']} → {t['to_scene']}（{t['duration_s']}s）") lines.append("") lines.append(f"**镜头**: {t['camera_motion']}") lines.append("") lines.append(f"{t['description']}") lines.append("") lines.append(f"🎥 T2V prompt → 见 `transition-{t['from_scene']:02d}-to-{t['to_scene']:02d}-t2v.txt`") lines.append("") lines.append("## 生产管线") lines.append("") lines.append("```bash") lines.append("# Step 1: 出每个 scene 的关键帧（T2I）") lines.append("for f in scene-*.txt; do") lines.append(" cat $f | grep -A100 '## Positive' | tail -1") lines.append(" # 喂给 Midjourney / DALL-E / SD ...") lines.append("done") lines.append("") lines.append("# Step 2: 出每个 transition 的衔接（T2V）") lines.append("for f in transition-*.txt; do") lines.append(" cat $f | grep -A100 '## Positive' | tail -1") lines.append(" # 喂给 Sora / Kling / Runway ...") lines.append("done") lines.append("") lines.append("# Step 3: 剪辑串联") lines.append("# scenes 用作关键帧定格；transitions 填充帧间动画") lines.append("```") lines.append("") lines.append(f"由 huo15-img-prompt v{result['version']} 故事板模式生成。") with open(p, "w", encoding="utf-8") as f: f.write("\n".join(lines) + "\n") written.append(p) return written def print_storyboard_summary(result: Dict): sep = "═" * 60 print(f"\n{sep}") print(f"🎬 故事板 v{result['version']}") print(f"📌 标题: {result['title']}") print(f"📝 简介: {result['logline']}") print(f"🎭 弧线: {result['narrative_arc']}") print(f"🎨 预设: {result['preset']}" + (f" + {result['mix_secondary']}" if result['mix_secondary'] else "")) print(f"📐 画幅: {result['aspect']}") print(f"🎲 锁定 seed: {result['base_seed']}") print(f"⏱ 估算: {result['estimated_duration_s']}s ({result['total_scenes']} 场 + {result['total_transitions']} 转场)") print(f"\n📋 场景列表:") for s in result["scenes"]: print(f" [{s['index']}] {s['subject'][:50]}") print(f" 角色: {s['narrative_role']} | 构图: {s['composition']} | 氛围: {s['lighting_atmosphere']}") print(f"\n🎥 转场:") for t in result["transitions"]: print(f" Scene {t['from_scene']} → {t['to_scene']}: {t['camera_motion']} ({t['duration_s']}s)") u = result.get("_claude", {}) print(f"\n📊 Claude token: in={u.get('input_tokens', 0)} / out={u.get('output_tokens', 0)} / cache={u.get('cache_read_input_tokens', 0)}") print(f"{sep}\n") def main(): parser = argparse.ArgumentParser( description=f"huo15-img-prompt storyboard v{VERSION} — 剧本→关键帧+转场视频脚本包", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=""" 示例: storyboard.py "一只猫从城市走进雨夜" -p 电影感 --scenes 4 -m Midjourney --video-model Sora storyboard.py < script.txt --scenes 8 --output ./my_story storyboard.py "汉服少女夜游京都" -p 汉服写真 --scenes 6 --video-model 即梦 """, ) parser.add_argument("script", nargs="?", help="剧本/文案（不给则从 stdin）") parser.add_argument("-p", "--preset", required=True, help="风格预设（支持 A+B 混合）") parser.add_argument("--scenes", type=int, default=5, help="拆几个关键帧（默认 5）") parser.add_argument("-a", "--aspect", default="", help="画幅（默认走预设默认）") parser.add_argument("-t", "--tier", choices=["basic", "pro", "master"], default="pro") parser.add_argument("-m", "--model", default="通用", help="T2I 适配模型 Midjourney/SD/SDXL/Flux/DALL-E/通用（默认通用）") parser.add_argument("--video-model", default="通用", help="T2V 适配模型 Sora/Kling/Runway/Pika/Luma/Hailuo/即梦/Wan/通用") parser.add_argument("--transition-duration", type=int, default=3, help="每个转场默认时长（秒）") parser.add_argument("--claude-model", default=DEFAULT_MODEL, help=f"Claude 模型（默认 {DEFAULT_MODEL}）") parser.add_argument("--output", default="", help="输出目录（不给则只打印）") parser.add_argument("-j", "--json", action="store_true", help="JSON 输出") parser.add_argument("-v", "--version", action="version", version=f"%(prog)s v{VERSION}") args = parser.parse_args() script = args.script if not script: if sys.stdin.isatty(): parser.print_help() sys.exit(1) script = sys.stdin.read().strip() if not script: print("❌ 剧本为空", file=sys.stderr) sys.exit(1) try: result = storyboard( script, preset=args.preset, target_scenes=args.scenes, i2i_model=args.model, t2v_model=args.video_model, aspect=args.aspect, duration_per_transition=args.transition_duration, quality_tier=args.tier, claude_model=args.claude_model, ) except RuntimeError as e: print(f"❌ {e}", file=sys.stderr) sys.exit(2) if args.output: files = write_storyboard_files(result, args.output) result["_files_written"] = files if args.json: print(json.dumps(result, ensure_ascii=False, indent=2)) else: print_storyboard_summary(result) print(f"📁 已写入 {len(files)} 个文件到 {args.output}/") for f in files[:5]: print(f" • {f}") if len(files) > 5: print(f" ... 还有 {len(files) - 5} 个") else: if args.json: print(json.dumps(result, ensure_ascii=False, indent=2)) else: print_storyboard_summary(result) print("💡 加 --output ./my_story 把所有 prompt 写到文件夹\n") if __name__ == "__main__": main() FILE:scripts/style_learn.py #!/usr/bin/env python3 """ huo15-img-prompt — 风格学习引擎 v3.0 给 N 张参考图（用户喜欢的风格样本），用 Claude Vision 提取每张的视觉特征，综合归纳出共性 → 生成一个新的"learned preset"，存到 ~/.huo15/learned_presets/.json。后续 enhance_prompt.py 用 `-p @` 复用这个学到的风格。工作流： Step 1: 对每张参考图调 Claude Vision 提取 tags / camera / lighting / palette Step 2: 用 Claude 综合 N 张图的共性，输出统一风格 spec Step 3: 保存为 learned preset，schema 与 STYLE_PRESETS 兼容调用： style_learn.py --name 我的小清新 ref1.jpg ref2.jpg ref3.jpg style_learn.py --list # 列出所有 learned presets style_learn.py --show 我的小清新 # 详情 style_learn.py --delete 旧风格 # 删除 enhance_prompt.py "猫咪" -p "@我的小清新" # 在出图时复用依赖： - 同目录 image_review.py (Claude Vision) - ANTHROPIC_API_KEY """ import sys import os import json import re import time import argparse from typing import Dict, List, Optional from urllib.request import Request, urlopen from urllib.error import HTTPError sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) from image_review import call_claude_vision, parse_review_json, ANTHROPIC_BASE, ANTHROPIC_VERSION VERSION = "3.1.0" DEFAULT_MODEL = "claude-sonnet-4-5" LEARNED_DIR = os.path.expanduser("~/.huo15/learned_presets") def safe_name(name: str) -> str: return re.sub(r"[^\w\-]", "_", name) def learned_path(name: str) -> str: return os.path.join(LEARNED_DIR, f"{safe_name(name)}.json") # ───────────────────────────────────────────────────────── # 单图特征提取（用 Claude Vision 但不是评分模式） # ───────────────────────────────────────────────────────── EXTRACT_SYSTEM_PROMPT = """你是图像视觉风格分析师。给一张图，提取它的可复现视觉风格 spec，输出严格 JSON： ```json { "tags": "用 5-8 个英文风格标签描述这张图，逗号分隔（例：'cinematic, anamorphic, golden hour, dreamy bokeh'）", "camera": "镜头/视角/焦段（英文，例：'85mm telephoto, low angle, shallow depth of field'）", "lighting": "光影描述（英文，例：'warm golden hour rim light, soft fill, cinematic glow'）", "palette": "主色板（英文，例：'muted teal and orange, warm amber highlights, soft pastels'）", "aspect": "推断画幅 1:1/3:4/4:3/16:9/9:16/21:9 之一", "subject_type": "主体类型（人像/风景/物品/抽象等）", "mood": "情绪关键词（中英混合）", "key_elements": ["3-5 个关键视觉元素"], "neg_to_avoid": "应该避免出现的事物（英文，逗号分隔）" } ``` 只输出 JSON，不要解释。""" def extract_image_style(image_src: str, model: str = DEFAULT_MODEL) -> Dict: """调 Claude Vision 提取一张图的视觉特征。""" api_key = os.environ.get("ANTHROPIC_API_KEY") if not api_key: raise RuntimeError("缺少 ANTHROPIC_API_KEY") from image_review import load_image_b64 img_b64, media_type = load_image_b64(image_src) body = { "model": model, "max_tokens": 1500, "system": [{ "type": "text", "text": EXTRACT_SYSTEM_PROMPT, "cache_control": {"type": "ephemeral"}, }], "messages": [ {"role": "user", "content": [ {"type": "image", "source": {"type": "base64", "media_type": media_type, "data": img_b64}}, {"type": "text", "text": "请提取这张图的视觉风格 spec，输出 JSON。"}, ]}, {"role": "assistant", "content": "{"}, ], } req = Request( f"{ANTHROPIC_BASE}/v1/messages", data=json.dumps(body).encode("utf-8"), headers={ "Content-Type": "application/json", "x-api-key": api_key, "anthropic-version": ANTHROPIC_VERSION, }, method="POST", ) try: with urlopen(req, timeout=120) as r: resp = json.loads(r.read().decode("utf-8")) except HTTPError as e: raise RuntimeError(f"Claude HTTP {e.code}: {e.read().decode('utf-8', errors='replace')}") return parse_review_json(resp) # ───────────────────────────────────────────────────────── # N 张图综合 → 共性 spec # ───────────────────────────────────────────────────────── SYNTHESIZE_SYSTEM_PROMPT = """你是视觉风格提炼师。给定 N 张参考图各自的风格 spec，提炼共性，输出一个统一的 huo15-img-prompt preset 定义。 # 输出 JSON 严格 schema（与 STYLE_PRESETS 兼容） ```json { "category": "推断分类（摄影/动漫/插画/3D/设计/艺术/场景/游戏/东方之一）", "tags": "5-10 个英文风格标签（必须是 N 张图共有的特征，去掉只在 1-2 张出现的）", "quality": "画质修饰词（英文，例：'masterpiece, raw photo, kodak portra 400 film stock'）", "neg": "负面词（英文逗号分隔，从 N 张图的 neg_to_avoid 综合）", "camera": "共性镜头（英文）", "lighting": "共性光影（英文）", "palette": "共性色板（英文）", "aspect": "最常出现的画幅", "synthesis_notes": "中文一句话说明这风格的精髓", "best_subject_examples": ["这风格适合画什么的 3 个例子"], "confidence": 0.0-1.0 } ``` # 关键 - 至少 50% 参考图共有的特征才算"共性" - 只出现在 1 张图的特征忽略 - tags 不要互相矛盾（"vintage" 和 "futuristic" 不应同时出现） - confidence 反映共性强度：> 0.7 才适合做新预设；< 0.5 说明 N 张图风格太散只输出 JSON，不要解释。""" def synthesize_style(per_image_specs: List[Dict], model: str = DEFAULT_MODEL) -> Dict: """让 Claude 综合 N 张图的共性。""" api_key = os.environ.get("ANTHROPIC_API_KEY") if not api_key: raise RuntimeError("缺少 ANTHROPIC_API_KEY") user_msg = f""" {json.dumps(per_image_specs, ensure_ascii=False, indent=2)} 请综合这 {len(per_image_specs)} 张图的共性，输出统一的 preset 定义 JSON。""" body = { "model": model, "max_tokens": 2000, "temperature": 0.5, "system": [{ "type": "text", "text": SYNTHESIZE_SYSTEM_PROMPT, "cache_control": {"type": "ephemeral"}, }], "messages": [ {"role": "user", "content": user_msg}, {"role": "assistant", "content": "{"}, ], } req = Request( f"{ANTHROPIC_BASE}/v1/messages", data=json.dumps(body).encode("utf-8"), headers={ "Content-Type": "application/json", "x-api-key": api_key, "anthropic-version": ANTHROPIC_VERSION, }, method="POST", ) try: with urlopen(req, timeout=60) as r: resp = json.loads(r.read().decode("utf-8")) except HTTPError as e: raise RuntimeError(f"Claude HTTP {e.code}: {e.read().decode('utf-8', errors='replace')}") return parse_review_json(resp) # ───────────────────────────────────────────────────────── # 主流程 # ───────────────────────────────────────────────────────── def learn_style(name: str, images: List[str], model: str = DEFAULT_MODEL) -> Dict: """主入口：N 张图 → learned preset。""" if len(images) < 2: raise RuntimeError("至少需要 2 张参考图") per_image = [] for i, img in enumerate(images, 1): print(f" 🔍 提取第 {i}/{len(images)} 张: {img}", file=sys.stderr) spec = extract_image_style(img, model=model) spec["_source"] = img per_image.append(spec) print(f" ✏️ 综合 {len(per_image)} 张图的共性...", file=sys.stderr) synthesized = synthesize_style(per_image, model=model) learned = { "name": name, "version": VERSION, "created_at": int(time.time()), "use_count": 0, "category": synthesized.get("category", "学习"), "tags": synthesized.get("tags", ""), "quality": synthesized.get("quality", "high quality, detailed"), "neg": synthesized.get("neg", "low quality, blurry"), "camera": synthesized.get("camera", ""), "lighting": synthesized.get("lighting", ""), "palette": synthesized.get("palette", ""), "aspect": synthesized.get("aspect", "1:1"), "synthesis_notes": synthesized.get("synthesis_notes", ""), "best_subject_examples": synthesized.get("best_subject_examples", []), "confidence": synthesized.get("confidence", 0.5), "source_count": len(images), "source_images": images, "per_image_specs": per_image, } os.makedirs(LEARNED_DIR, exist_ok=True) with open(learned_path(name), "w", encoding="utf-8") as f: json.dump(learned, f, ensure_ascii=False, indent=2) return learned def learned_load(name: str) -> Optional[Dict]: p = learned_path(name) if not os.path.isfile(p): return None try: with open(p, "r", encoding="utf-8") as f: return json.load(f) except (json.JSONDecodeError, IOError): return None def learned_list() -> List[Dict]: if not os.path.isdir(LEARNED_DIR): return [] out = [] for fn in sorted(os.listdir(LEARNED_DIR)): if not fn.endswith(".json"): continue try: with open(os.path.join(LEARNED_DIR, fn), "r", encoding="utf-8") as f: out.append(json.load(f)) except (json.JSONDecodeError, IOError): continue return out def learned_delete(name: str) -> bool: p = learned_path(name) if os.path.isfile(p): os.remove(p) return True return False def print_learned(p: Dict): print(f"\n🎨 @{p['name']}") print(f" 分类: {p.get('category', '?')}") print(f" Confidence: {p.get('confidence', 0):.2f}") print(f" 来源: {p.get('source_count', 0)} 张图") print(f" 用过: {p.get('use_count', 0)} 次") print(f" 风格标签: {p.get('tags', '')[:120]}") if p.get("camera"): print(f" 相机: {p['camera']}") if p.get("lighting"): print(f" 光影: {p['lighting']}") if p.get("palette"): print(f" 色板: {p['palette']}") if p.get("synthesis_notes"): print(f"\n 📝 精髓: {p['synthesis_notes']}") if p.get("best_subject_examples"): print(f" 💡 适合画:") for e in p["best_subject_examples"]: print(f" • {e}") def main(): parser = argparse.ArgumentParser( description=f"huo15-img-prompt style_learn v{VERSION} — 风格学习引擎", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=""" 示例: style_learn.py --name 我的小清新 ref1.jpg ref2.jpg ref3.jpg style_learn.py --list style_learn.py --show 我的小清新 style_learn.py --delete 旧风格 ✨ 在 enhance_prompt.py 里使用: enhance_prompt.py "猫咪" -p "@我的小清新" """, ) g = parser.add_mutually_exclusive_group(required=True) g.add_argument("--name", help="给学到的风格起个名字（配合 image 参数）") g.add_argument("--list", action="store_true", help="列出所有 learned preset") g.add_argument("--show", help="显示详情") g.add_argument("--delete", help="删除") parser.add_argument("images", nargs="*", help="参考图路径或 URL（≥2 张）") parser.add_argument("--model", default=DEFAULT_MODEL, help=f"Claude 模型（默认 {DEFAULT_MODEL}）") parser.add_argument("-j", "--json", action="store_true", help="JSON 输出") parser.add_argument("-v", "--version", action="version", version=f"%(prog)s v{VERSION}") args = parser.parse_args() if args.list: ps = learned_list() if args.json: print(json.dumps({"version": VERSION, "learned_presets": ps}, ensure_ascii=False, indent=2)) return if not ps: print(f"\n📭 暂无 learned preset ({LEARNED_DIR})") print("💡 创建：style_learn.py --name 我的风格 ref1.jpg ref2.jpg ref3.jpg\n") return print(f"\n🎨 Learned Presets ({len(ps)} 个):") for p in ps: print(f" • @{p['name']:20s} {p.get('category', '?'):10s} conf={p.get('confidence', 0):.2f} {p.get('source_count', 0)} 图用过 {p.get('use_count', 0)} 次") print() return if args.show: p = learned_load(args.show) if not p: print(f"❌ 不存在: {args.show}", file=sys.stderr) sys.exit(1) if args.json: print(json.dumps(p, ensure_ascii=False, indent=2)) else: print_learned(p) print() return if args.delete: if learned_delete(args.delete): print(f"✅ 已删除: @{args.delete}") else: print(f"❌ 不存在: {args.delete}", file=sys.stderr) sys.exit(1) return if args.name: if not args.images: print(f"❌ 至少需要 2 张参考图", file=sys.stderr) sys.exit(1) try: learned = learn_style(args.name, args.images, model=args.model) except RuntimeError as e: print(f"❌ {e}", file=sys.stderr) sys.exit(2) if args.json: print(json.dumps(learned, ensure_ascii=False, indent=2)) else: print_learned(learned) print(f"\n✅ 已保存: ~/.huo15/learned_presets/{safe_name(args.name)}.json") print(f"💡 使用: enhance_prompt.py \"主体\" -p \"@{args.name}\"\n") if __name__ == "__main__": main() FILE:scripts/web_ui.py #!/usr/bin/env python3 """ huo15-img-prompt — 本地 Web UI v2.6 启动一个本地 HTTP server（默认 http://127.0.0.1:7155），自动打开浏览器，提供 88 风格预设可视化选择 + 实时 prompt 预览 + 一键复制。启动： web_ui.py # 默认 7155 端口 web_ui.py --port 8080 # 指定端口 web_ui.py --no-browser # 不自动开浏览器 web_ui.py --host 0.0.0.0 # 局域网可访问零第三方依赖，纯 Python 标准库 http.server + 单文件嵌入 HTML。 """ import sys import os import json import re import argparse import webbrowser from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer from urllib.parse import urlparse, parse_qs sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) from enhance_prompt import ( build_prompt, parse_mix_preset, resolve_preset, parse_requirement, STYLE_PRESETS, preset_example_urls, compact_prompt, ) from character import char_list, char_load VERSION = "3.1.0" # ───────────────────────────────────────────────────────── # 单文件 HTML（vanilla JS + Tailwind CDN） # ───────────────────────────────────────────────────────── HTML_PAGE = """ 火一五文生图提示词 v__VERSION__

🔥 火一五文生图提示词 vVERSION

📦 ClawHub →

主体描述

混合预设（可选）

主预设权重 0.60

画质

目标模型

画幅

压缩到 77 token 角色设定图

角色卡

88 风格预设

👈 选预设 + 写主体 + 点生成

""".replace("__VERSION__", VERSION) # ───────────────────────────────────────────────────────── # HTTP handlers # ───────────────────────────────────────────────────────── class Handler(BaseHTTPRequestHandler): def log_message(self, fmt, *args): pass # 静默 def _send_json(self, code: int, payload: dict): body = json.dumps(payload, ensure_ascii=False).encode("utf-8") self.send_response(code) self.send_header("Content-Type", "application/json; charset=utf-8") self.send_header("Content-Length", str(len(body))) self.send_header("Access-Control-Allow-Origin", "*") self.end_headers() self.wfile.write(body) def _send_html(self, code: int, html: str): body = html.encode("utf-8") self.send_response(code) self.send_header("Content-Type", "text/html; charset=utf-8") self.send_header("Content-Length", str(len(body))) self.end_headers() self.wfile.write(body) def do_GET(self): path = urlparse(self.path).path if path == "/" or path == "/index.html": self._send_html(200, HTML_PAGE) elif path == "/api/presets": data = [] for name, p in STYLE_PRESETS.items(): data.append({ "name": name, "category": p["category"], "tags": p["tags"], "aspect": p.get("aspect", "1:1"), }) self._send_json(200, {"version": VERSION, "presets": data}) elif path == "/api/characters": self._send_json(200, {"characters": char_list()}) elif path == "/api/preset-examples": qs = parse_qs(urlparse(self.path).query) preset = (qs.get("preset") or [""])[0] resolved = resolve_preset(preset) or preset if resolved not in STYLE_PRESETS: self._send_json(404, {"error": f"未知预设 {preset}"}) return self._send_json(200, preset_example_urls(resolved)) else: self._send_json(404, {"error": "not found"}) def do_POST(self): path = urlparse(self.path).path length = int(self.headers.get("Content-Length", 0)) body_bytes = self.rfile.read(length) if length else b"{}" try: body = json.loads(body_bytes.decode("utf-8")) except json.JSONDecodeError: self._send_json(400, {"error": "invalid JSON"}) return if path == "/api/enhance": try: subject = body.get("subject", "") raw_preset = body.get("preset", "写实摄影") primary, secondary = parse_mix_preset(raw_preset) if secondary: p1, p2 = resolve_preset(primary), resolve_preset(secondary) if not p1 or not p2: self._send_json(400, {"error": f"未知预设 {primary} 或 {secondary}"}) return preset, mix_secondary = p1, p2 else: preset = resolve_preset(primary) or "写实摄影" mix_secondary = None # 角色卡注入 char_name = body.get("char") if char_name: card = char_load(char_name) if card: if card.get("subject_description"): subject = f"{card['subject_description']}, {subject}" body.setdefault("seed", card.get("seed")) aspect = body.get("aspect") or STYLE_PRESETS[preset].get("aspect", "1:1") result = build_prompt( subject, preset, body.get("model", "通用"), aspect, extra_negatives="", seed=body.get("seed"), quality_tier=body.get("tier", "pro"), character_sheet=bool(body.get("character_sheet", False)), mix_secondary=mix_secondary, mix_ratio=float(body.get("mix_ratio", 0.6)), ) if body.get("compact"): compacted, meta = compact_prompt(result["positive"]) result["positive_original"] = result["positive"] result["positive"] = compacted result["compaction"] = meta self._send_json(200, result) except Exception as e: self._send_json(500, {"error": str(e)}) else: self._send_json(404, {"error": "not found"}) def do_OPTIONS(self): self.send_response(204) self.send_header("Access-Control-Allow-Origin", "*") self.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS") self.send_header("Access-Control-Allow-Headers", "Content-Type") self.end_headers() def main(): parser = argparse.ArgumentParser( description=f"huo15-img-prompt web_ui v{VERSION} — 本地 Web UI", ) parser.add_argument("--host", default="127.0.0.1", help="监听地址（默认 127.0.0.1）") parser.add_argument("--port", type=int, default=7155, help="端口（默认 7155）") parser.add_argument("--no-browser", action="store_true", help="不自动开浏览器") parser.add_argument("-v", "--version", action="version", version=f"%(prog)s v{VERSION}") args = parser.parse_args() server = ThreadingHTTPServer((args.host, args.port), Handler) url = f"http://{args.host}:{args.port}" print(f"🌐 huo15-img-prompt Web UI v{VERSION}") print(f" → {url}") print(f" 按 Ctrl+C 停止\n") if not args.no_browser: try: webbrowser.open(url) except Exception: pass try: server.serve_forever() except KeyboardInterrupt: print("\n👋 已停止") server.shutdown() if __name__ == "__main__": main() FILE:tests/smoke.py #!/usr/bin/env python3 """ huo15-img-prompt — Smoke 回归测试 v3.1 本地、零依赖、不调网络的快速回归。每个脚本几个核心 CASE： - 版本号正确 - 基础 import 不出错 - 核心函数能跑（用 mock / 离线场景）不覆盖的： - 真正调 Claude API（要 key + 钱） - 真正出图（要后端服务） - VLM 评审（要图 + key）调用： tests/smoke.py # 全跑 tests/smoke.py --module enhance_prompt tests/smoke.py -v # verbose """ import sys import os import json import re import unittest import argparse import tempfile from pathlib import Path # 让 tests/ 目录里的脚本能 import scripts/ ROOT = Path(__file__).resolve().parent.parent sys.path.insert(0, str(ROOT / "scripts")) EXPECTED_VERSION = "3.1.0" SCRIPTS = [ "enhance_prompt", "enhance_video", "reverse_prompt", "render_prompt", "claude_polish", "safety_lint", "image_review", "auto_iterate", "character", "mcp_server", "web_ui", "storyboard", "brand_kit", "style_learn", "doctor", ] class TestVersionConsistency(unittest.TestCase): """所有脚本的 VERSION 必须一致。""" def test_all_scripts_have_version(self): for name in SCRIPTS: with self.subTest(script=name): mod = __import__(name) self.assertTrue(hasattr(mod, "VERSION"), f"{name} 缺 VERSION") self.assertEqual(mod.VERSION, EXPECTED_VERSION, f"{name} 版本 {mod.VERSION} != {EXPECTED_VERSION}") class TestEnhancePromptCore(unittest.TestCase): def setUp(self): from enhance_prompt import build_prompt, resolve_preset, parse_mix_preset self.build_prompt = build_prompt self.resolve_preset = resolve_preset self.parse_mix_preset = parse_mix_preset def test_resolve_preset_chinese(self): self.assertEqual(self.resolve_preset("动漫"), "动漫") def test_resolve_preset_english_alias(self): self.assertEqual(self.resolve_preset("genshin"), "原神") self.assertEqual(self.resolve_preset("ghibli"), "宫崎骏") self.assertEqual(self.resolve_preset("cyberpunk"), "赛博朋克") def test_resolve_preset_unknown(self): self.assertEqual(self.resolve_preset("不存在的预设"), "") def test_resolve_learned_preset_missing(self): # @ 前缀但 learned preset 不存在 self.assertEqual(self.resolve_preset("@nonexist_preset_xyz"), "") def test_parse_mix_preset(self): primary, secondary = self.parse_mix_preset("赛博朋克+水墨") self.assertEqual(primary, "赛博朋克") self.assertEqual(secondary, "水墨") def test_parse_mix_preset_no_plus(self): primary, secondary = self.parse_mix_preset("赛博朋克") self.assertEqual(primary, "赛博朋克") self.assertIsNone(secondary) def test_build_prompt_basic(self): r = self.build_prompt("一只猫", "动漫", model="通用") self.assertIn("positive", r) self.assertIn("negative", r) self.assertIn("seed_suggestion", r) self.assertIn("一只猫", r["positive"]) self.assertEqual(r["preset"], "动漫") def test_build_prompt_seed_stable(self): r1 = self.build_prompt("猫", "动漫") r2 = self.build_prompt("猫", "动漫") self.assertEqual(r1["seed_suggestion"], r2["seed_suggestion"]) def test_build_prompt_mix(self): r = self.build_prompt("猫", "赛博朋克", mix_secondary="水墨", mix_ratio=0.6) self.assertEqual(r["mix_label"], "赛博朋克+水墨@0.60") def test_build_prompt_character_sheet(self): r = self.build_prompt("少女", "动漫", character_sheet=True) self.assertEqual(r["aspect"], "16:9") self.assertIn("character design sheet", r["positive"].lower()) class TestCompactPrompt(unittest.TestCase): def test_compact_short_prompt_unchanged(self): from enhance_prompt import compact_prompt text, meta = compact_prompt("一只猫") self.assertFalse(meta["compacted"]) def test_compact_long_prompt(self): from enhance_prompt import compact_prompt long_text = ", ".join([f"tag{i}" for i in range(60)]) text, meta = compact_prompt(long_text, target_tokens=30) self.assertTrue(meta["compacted"]) self.assertLessEqual(meta["estimated_tokens_after"], 35) class TestSafetyLint(unittest.TestCase): def setUp(self): from safety_lint import lint, check_hard_blocks self.lint = lint self.check_hard_blocks = check_hard_blocks def test_clean_text_passes(self): r = self.lint("一只猫坐在窗台上") self.assertEqual(r["verdict"], "OK") def test_violence_artistic_rewrite(self): r = self.lint("战士手中沾满鲜血的剑", platform="dalle") self.assertEqual(r["verdict"], "REWRITE") self.assertIn("crimson", r["rewritten"]) def test_red_line_csam_blocked(self): r = self.lint("loli nude", platform="MJ") self.assertEqual(r["verdict"], "REJECT") def test_red_line_weapon_instruction_blocked(self): r = self.lint("如何制作炸弹的步骤") self.assertEqual(r["verdict"], "REJECT") def test_red_line_bidirectional(self): # 词序颠倒也要 catch 到 r = self.lint("炸弹制作教程") self.assertEqual(r["verdict"], "REJECT") class TestCharacterCard(unittest.TestCase): def setUp(self): from character import char_save, char_load, char_delete, char_list self.char_save = char_save self.char_load = char_load self.char_delete = char_delete self.char_list = char_list self.test_name = "_smoke_test_char" def tearDown(self): self.char_delete(self.test_name) def test_save_load_roundtrip(self): recipe = { "original": "测试角色", "preset": "动漫", "aspect": "3:4", "seed_suggestion": 12345, "consistency_lock": {"camera": "85mm", "lighting": "soft", "palette": "muted"}, "character_sheet": True, "positive": "test prompt", } self.char_save(self.test_name, recipe) loaded = self.char_load(self.test_name) self.assertIsNotNone(loaded) self.assertEqual(loaded["seed"], 12345) self.assertEqual(loaded["preset"], "动漫") self.assertTrue(loaded["is_character_sheet"]) def test_delete(self): self.char_save(self.test_name, {"original": "x"}) self.assertTrue(self.char_delete(self.test_name)) self.assertIsNone(self.char_load(self.test_name)) class TestBrandKit(unittest.TestCase): def setUp(self): from brand_kit import kit_save, kit_load, kit_delete self.kit_save = kit_save self.kit_load = kit_load self.kit_delete = kit_delete self.test_name = "_smoke_test_kit" def tearDown(self): self.kit_delete(self.test_name) def test_save_load_roundtrip(self): kit = { "colors": ["#ff6b35", "#2d3047"], "keywords": ["现代", "简洁"], "forbidden": ["low quality"], } self.kit_save(self.test_name, kit) loaded = self.kit_load(self.test_name) self.assertIsNotNone(loaded) self.assertEqual(loaded["colors"], ["#ff6b35", "#2d3047"]) def test_kit_apply_injects_keywords(self): from brand_kit import kit_apply self.kit_save(self.test_name, { "colors": ["#ff6b35"], "keywords": ["现代", "简洁"], "forbidden": ["blur"], }) class FakeArgs: subject = "测试主体" avoid = "" args = FakeArgs() kit = kit_apply(self.test_name, args) self.assertIsNotNone(kit) self.assertIn("现代", args.subject) self.assertIn("blur", args.avoid) class TestVariants(unittest.TestCase): def test_build_variants_count(self): from enhance_prompt import build_variants variants = build_variants("test", "动漫", "通用", "1:1", axes=["mood", "composition"], n=4) self.assertEqual(len(variants), 4) # 所有变体共享同一 seed seeds = set(v["seed_suggestion"] for v in variants) self.assertEqual(len(seeds), 1, "variants 应共享 seed") def test_build_variants_descriptors_unique(self): from enhance_prompt import build_variants variants = build_variants("test", "动漫", "通用", "1:1", axes=["mood", "composition"], n=4) descriptors = [v["variant_descriptor"] for v in variants] self.assertEqual(len(set(descriptors)), 4, "descriptors 应不重复") class TestReversePromptParser(unittest.TestCase): def test_a1111_parse(self): from reverse_prompt import parse_a1111_params text = ("a beautiful cat\n" "Negative prompt: low quality, blur\n" "Steps: 30, Sampler: DPM++ 2M Karras, Seed: 12345, Size: 1024x1024") r = parse_a1111_params(text) self.assertIn("a beautiful cat", r["positive"]) self.assertEqual(r["seed"], "12345") self.assertEqual(r["sampler"], "DPM++ 2M Karras") def test_guess_preset(self): from reverse_prompt import guess_preset self.assertEqual(guess_preset("cyberpunk neon city"), "赛博朋克") self.assertEqual(guess_preset("studio ghibli forest"), "宫崎骏") self.assertEqual(guess_preset("dunhuang mural"), "敦煌壁画") def test_guess_aspect(self): from reverse_prompt import guess_aspect self.assertEqual(guess_aspect("1024x1024"), "1:1") self.assertEqual(guess_aspect("1792x1024"), "16:9") class TestMCPServer(unittest.TestCase): def test_handle_initialize(self): from mcp_server import handle_request resp = handle_request({"jsonrpc": "2.0", "id": 1, "method": "initialize"}) self.assertEqual(resp["jsonrpc"], "2.0") self.assertIn("protocolVersion", resp["result"]) self.assertIn("serverInfo", resp["result"]) def test_handle_tools_list(self): from mcp_server import handle_request, TOOLS resp = handle_request({"jsonrpc": "2.0", "id": 2, "method": "tools/list"}) self.assertEqual(resp["result"]["tools"], TOOLS) self.assertGreaterEqual(len(TOOLS), 9) def test_handle_unknown_method(self): from mcp_server import handle_request resp = handle_request({"jsonrpc": "2.0", "id": 3, "method": "fake/method"}) self.assertIn("error", resp) self.assertEqual(resp["error"]["code"], -32601) def test_tools_call_enhance_prompt(self): from mcp_server import handle_request resp = handle_request({ "jsonrpc": "2.0", "id": 4, "method": "tools/call", "params": {"name": "enhance_prompt", "arguments": {"subject": "猫", "preset": "动漫"}}, }) self.assertIn("result", resp) self.assertIn("content", resp["result"]) text = resp["result"]["content"][0]["text"] result = json.loads(text) self.assertEqual(result["preset"], "动漫") class TestPresetCount(unittest.TestCase): def test_88_presets(self): from enhance_prompt import STYLE_PRESETS self.assertEqual(len(STYLE_PRESETS), 88, f"应该是 88 预设，实际 {len(STYLE_PRESETS)}") def test_all_presets_have_required_fields(self): from enhance_prompt import STYLE_PRESETS for name, p in STYLE_PRESETS.items(): with self.subTest(preset=name): for field in ("category", "tags", "quality", "neg", "aspect"): self.assertIn(field, p, f"{name} 缺 {field}") def main(): parser = argparse.ArgumentParser(description="huo15-img-prompt smoke tests") parser.add_argument("--module", help="只跑指定模块的测试（按 TestCase 名匹配）") parser.add_argument("-v", "--verbose", action="count", default=1) args = parser.parse_args() loader = unittest.TestLoader() if args.module: suite = loader.loadTestsFromName(args.module, sys.modules[__name__]) else: suite = loader.loadTestsFromModule(sys.modules[__name__]) runner = unittest.TextTestRunner(verbosity=args.verbose) result = runner.run(suite) sys.exit(0 if result.wasSuccessful() else 1) if __name__ == "__main__": main()

Huo15 Img Prompt

Comments (0)