Multi Agent Image

#!/usr/bin/env python3
"""
📦 批量图片生成器 v2 (多Agent版)
=================================
每张图都走完整的 5-Agent 工作流！

支持三种批量模式：
1. 同需求多风格 (A/B 测试)
2. 同需求多比例 (多尺寸适配)
3. 多需求批量 (内容矩阵)

使用方式:
    from batch_generator_v2 import BatchGeneratorV2
    
    bg = BatchGeneratorV2()
    
    # 模式1: 同需求多风格
    bg.batch_styles("AI训练营海报", task="poster")
    
    # 模式2: 同需求多比例
    bg.batch_aspects("AI训练营海报", task="poster")
    
    # 模式3: 多需求批量
    bg.batch_briefs(["海报A", "海报B", "海报C"], task="poster")
"""

import os
import sys
import time
from pathlib import Path
from datetime import datetime
from typing import List, Dict

AGENCY_DIR = Path.home() / ".hermes/agents/multi-agent-image"
sys.path.insert(0, str(AGENCY_DIR))

from orchestrator_v2 import run

class BatchGeneratorV2:
    """批量图片生成器（多Agent版）"""

    def __init__(self):
        self.results = []
        self.start_time = None

    def log(self, msg: str):
        ts = datetime.now().strftime("%H:%M:%S")
        print(f"[{ts}] [批量生成] {msg}")

    def batch_styles(self, brief: str, task: str = "poster", aspect: str = "1:1",
                     quality: str = "final", use_reference: bool = True) -> List[dict]:
        """
        模式1: 同需求多风格（A/B 测试）
        同一个 brief，让 Agent 生成保守/平衡/大胆三个版本
        """
        directions = ["conservative", "balanced", "bold"]
        self.log(f"启动多风格批量生成（多Agent）: {brief[:30]}...")
        self.log(f"将生成 {len(directions)} 个版本")

        self.results = []
        self.start_time = time.time()

        for i, direction in enumerate(directions):
            print(f"\n{'='*70}")
            print(f"🎨 批量 [{i+1}/{len(directions)}] 风格: {direction}")
            print(f"{'='*70}")

            # 走完整多Agent工作流，但强制指定 direction
            result = run(
                user_input=brief,
                use_reference=use_reference,
                task=task,
                direction=direction,
                aspect=aspect,
                quality=quality
            )
            result["batch_mode"] = "style"
            result["batch_param"] = direction
            result["batch_index"] = i
            self.results.append(result)

        self._print_summary()
        return self.results

    def batch_aspects(self, brief: str, task: str = "poster", direction: str = "balanced",
                      aspects: List[str] = None, quality: str = "final",
                      use_reference: bool = True) -> List[dict]:
        """
        模式2: 同需求多比例（多尺寸适配）
        同一个 brief，生成多个比例
        """
        if aspects is None:
            aspects = ["1:1", "16:9", "9:16"]

        self.log(f"启动多比例批量生成（多Agent）: {brief[:30]}...")
        self.log(f"将生成 {len(aspects)} 个比例")

        self.results = []
        self.start_time = time.time()

        for i, aspect in enumerate(aspects):
            print(f"\n{'='*70}")
            print(f"📐 批量 [{i+1}/{len(aspects)}] 比例: {aspect}")
            print(f"{'='*70}")

            result = run(
                user_input=brief,
                use_reference=use_reference,
                task=task,
                direction=direction,
                aspect=aspect,
                quality=quality
            )
            result["batch_mode"] = "aspect"
            result["batch_param"] = aspect
            result["batch_index"] = i
            self.results.append(result)

        self._print_summary()
        return self.results

    def batch_briefs(self, briefs: List[str], task: str = "poster", direction: str = "balanced",
                     aspect: str = "1:1", quality: str = "final",
                     use_reference: bool = True) -> List[dict]:
        """
        模式3: 多需求批量（内容矩阵）
        多个不同的 brief，每张都走完整 Agent 工作流
        """
        self.log(f"启动多需求批量生成（多Agent）: {len(briefs)} 张")
        self.results = []
        self.start_time = time.time()

        for i, brief in enumerate(briefs):
            print(f"\n{'='*70}")
            print(f"🎨 批量 [{i+1}/{len(briefs)}] {brief[:40]}...")
            print(f"{'='*70}")

            # 走完整多Agent工作流（让Agent自己判断参数）
            result = run(
                user_input=brief,
                use_reference=use_reference
            )
            result["batch_mode"] = "brief"
            result["batch_param"] = brief[:30]
            result["batch_index"] = i
            self.results.append(result)

        self._print_summary()
        return self.results

    def _print_summary(self):
        """打印批量生成摘要"""
        elapsed = time.time() - self.start_time if self.start_time else 0
        total = len(self.results)
        success = sum(1 for r in self.results if r.get("success"))
        failed = total - success

        print("\n" + "=" * 70)
        print("📦 批量生成完成!（多Agent版）")
        print("=" * 70)
        print(f"\n📊 统计:")
        print(f"   总计: {total} 张")
        print(f"   ✅ 成功: {success} 张")
        print(f"   ❌ 失败: {failed} 张")
        print(f"   ⏱️  总耗时: {elapsed:.1f} 秒")
        print(f"   ⚡ 平均: {elapsed/max(total,1):.1f} 秒/张")

        print(f"\n📁 成功文件:")
        for r in self.results:
            if r.get("success"):
                mode = r.get("batch_mode", "")
                param = r.get("batch_param", "")
                filepath = r.get("filepath", "")
                score = r.get("score", 0)
                if filepath:
                    print(f"   ✅ [{mode}/{param}] {Path(filepath).name} ⭐{score}")
            else:
                print(f"   ❌ [{r.get('batch_index', '?')}] {r.get('error', 'Unknown')}")

        # 案例库统计
        from case_library import list_cases
        total_cases = len(list_cases())
        print(f"\n📚 案例库: 共 {total_cases} 个案例")
        print()

# 快捷函数
def batch_styles(brief: str, **kwargs):
    """同需求多风格（多Agent）"""
    return BatchGeneratorV2().batch_styles(brief, **kwargs)

def batch_aspects(brief: str, **kwargs):
    """同需求多比例（多Agent）"""
    return BatchGeneratorV2().batch_aspects(brief, **kwargs)

def batch_briefs(briefs: List[str], **kwargs):
    """多需求批量（多Agent）"""
    return BatchGeneratorV2().batch_briefs(briefs, **kwargs)

if __name__ == "__main__":
    import sys
    if len(sys.argv) < 2:
        print("用法:")
        print('  python batch_generator_v2.py styles "AI训练营海报"')
        print('  python batch_generator_v2.py aspects "AI训练营海报"')
        print('  python batch_generator_v2.py briefs "海报A" "海报B" "海报C"')
        sys.exit(1)

    mode = sys.argv[1]
    brief = sys.argv[2] if len(sys.argv) > 2 else "测试海报"

    bg = BatchGeneratorV2()
    if mode == "styles":
        bg.batch_styles(brief)
    elif mode == "aspects":
        bg.batch_aspects(brief)
    elif mode == "briefs":
        bg.batch_briefs(sys.argv[2:])

#!/usr/bin/env python3
"""
📚 案例库系统 (Case Library)
=======================
功能：
1. 保存生成的图片到案例库（按任务类型分类）
2. 列出案例库中的所有案例
3. 选择案例作为参考图，进行风格迁移（图生图）
4. 支持案例打标签、评分、搜索

案例库路径：
/root/.hermes/agents/multi-agent-image/case_library/
├── poster/
│   ├── case_001_赛博朋克海报/
│   │   ├── image.png
│   │   └── metadata.json
│   └── case_002_AI训练营海报/
│       ├── image.png
│       └── metadata.json
├── product/
├── ppt/
├── infographic/
└── teaching/
"""

import os
import sys
import json
import shutil
from pathlib import Path
from datetime import datetime

AGENCY_DIR = Path.home() / ".hermes/agents/multi-agent-image"
CASE_LIBRARY_DIR = AGENCY_DIR / "case_library"
CASE_LIBRARY_DIR.mkdir(parents=True, exist_ok=True)

# 为每种任务类型创建目录
for task in ["poster", "product", "ppt", "infographic", "teaching"]:
    (CASE_LIBRARY_DIR / task).mkdir(exist_ok=True)

def log(msg):
    print(f"[案例库] {msg}")

def add_case(image_path: str, metadata: dict, task: str = "poster", tags: list = None) -> str:
    """
    添加案例到案例库

    Args:
        image_path: 图片路径
        metadata: 元数据（包含 prompt、params 等）
        task: 任务类型
        tags: 标签列表

    Returns:
        案例 ID
    """
    task_dir = CASE_LIBRARY_DIR / task

    # 生成案例编号
    existing = [d for d in task_dir.iterdir() if d.is_dir()]
    case_num = len(existing) + 1
    case_id = f"case_{case_num:03d}"

    # 创建案例目录
    case_dir = task_dir / f"{case_id}_{metadata.get('brief', 'untitled')[:20]}"
    case_dir.mkdir(exist_ok=True)

    # 复制图片
    ext = Path(image_path).suffix
    target_image = case_dir / f"image{ext}"
    shutil.copy2(image_path, target_image)

    # 保存元数据
    case_meta = {
        "case_id": case_id,
        "task": task,
        "created_at": datetime.now().isoformat(),
        "image_path": str(target_image),
        "brief": metadata.get("brief", ""),
        "prompt": metadata.get("prompt", ""),
        "params": metadata.get("params", {}),
        "tags": tags or [],
        "rating": metadata.get("rating", 0),
    }

    with open(case_dir / "metadata.json", 'w', encoding='utf-8') as f:
        json.dump(case_meta, f, indent=2, ensure_ascii=False)

    log(f"✅ 案例已保存: {case_dir.name}")
    return case_id

def list_cases(task: str = None) -> list:
    """
    列出案例库中的所有案例

    Args:
        task: 按任务类型过滤 (poster/product/ppt/infographic/teaching)
              None = 显示全部

    Returns:
        案例列表
    """
    cases = []

    tasks_to_list = [task] if task else ["poster", "product", "ppt", "infographic", "teaching"]

    for t in tasks_to_list:
        task_dir = CASE_LIBRARY_DIR / t
        if not task_dir.exists():
            continue

        for case_dir in sorted(task_dir.iterdir()):
            if not case_dir.is_dir():
                continue

            meta_file = case_dir / "metadata.json"
            if meta_file.exists():
                with open(meta_file, 'r', encoding='utf-8') as f:
                    meta = json.load(f)
                cases.append(meta)

    return cases

def search_cases(keyword: str, task: str = None) -> list:
    """搜索案例（按关键词匹配 brief、prompt、tags）"""
    all_cases = list_cases(task)
    keyword_lower = keyword.lower()

    results = []
    for case in all_cases:
        text_to_search = " ".join([
            case.get("brief", ""),
            case.get("prompt", ""),
            " ".join(case.get("tags", []))
        ]).lower()

        if keyword_lower in text_to_search:
            results.append(case)

    return results

def get_case_image_path(case_id: str, task: str = None) -> str:
    """
    获取案例图片路径

    Args:
        case_id: 案例编号 (如 "case_001")
        task: 任务类型（如果知道）

    Returns:
        图片路径，找不到返回 None
    """
    if task:
        task_dirs = [CASE_LIBRARY_DIR / task]
    else:
        task_dirs = [CASE_LIBRARY_DIR / t for t in ["poster", "product", "ppt", "infographic", "teaching"]]

    for task_dir in task_dirs:
        if not task_dir.exists():
            continue
        for case_dir in task_dir.iterdir():
            if case_dir.name.startswith(case_id):
                for ext in [".png", ".jpg", ".jpeg", ".webp"]:
                    img = case_dir / f"image{ext}"
                    if img.exists():
                        return str(img)
    return None

def print_case_list(cases: list):
    """打印案例列表（美观格式）"""
    if not cases:
        print("   (暂无案例)")
        return

    for case in cases:
        case_id = case.get("case_id", "N/A")
        brief = case.get("brief", "无标题")[:30]
        task = case.get("task", "unknown")
        rating = case.get("rating", 0)
        tags = ", ".join(case.get("tags", [])[:3])
        stars = "⭐" * int(rating) if rating else ""

        print(f"   {case_id} [{task}] {brief} {stars}")
        if tags:
            print(f"      🏷️  {tags}")

def interactive_select_case(task: str = None) -> str:
    """
    交互式选择案例

    Returns:
        选中的案例图片路径，或 None（不选择）
    """
    print("\n" + "=" * 60)
    print("📚 案例库")
    print("=" * 60)

    cases = list_cases(task)

    if not cases:
        print("\n案例库为空，直接生成新图片。\n")
        return None

    print(f"\n找到 {len(cases)} 个案例:\n")
    print_case_list(cases)

    print("\n选项:")
    print("  [1-N] 选择案例编号参考")
    print("  [s]   搜索案例")
    print("  [n]   不参考案例，直接生成")
    print()

    choice = input("你的选择: ").strip().lower()

    if choice == 'n' or not choice:
        print("   → 不参考案例\n")
        return None

    if choice == 's':
        keyword = input("搜索关键词: ").strip()
        results = search_cases(keyword, task)
        if results:
            print(f"\n搜索结果 ({len(results)} 个):")
            print_case_list(results)
            idx = input("选择编号 (1-N): ").strip()
            try:
                selected = results[int(idx) - 1]
                return selected["image_path"]
            except:
                print("   → 无效选择，不参考案例\n")
                return None
        else:
            print("   → 未找到匹配案例\n")
            return None

    # 按编号选择
    try:
        idx = int(choice) - 1
        if 0 <= idx < len(cases):
            selected = cases[idx]
            print(f"   → 已选择: {selected['case_id']} - {selected['brief'][:30]}\n")
            return selected["image_path"]
    except:
        pass

    print("   → 无效选择，不参考案例\n")
    return None

def auto_save_to_library(generation_result: dict, brief: str, params: dict):
    """自动生成完成后，自动保存到案例库"""
    if generation_result.get("status") != "success":
        return

    filepath = generation_result.get("filepath")
    if not filepath or not os.path.exists(filepath):
        return

    metadata = {
        "brief": brief,
        "prompt": generation_result.get("final_prompt", ""),
        "params": params,
        "rating": 0,
    }

    task = params.get("task", "poster")
    add_case(filepath, metadata, task=task)

# 快捷命令
def lib():
    """查看案例库"""
    print("\n📚 案例库概览:\n")
    for task in ["poster", "product", "ppt", "infographic", "teaching"]:
        cases = list_cases(task)
        print(f"【{task}】({len(cases)} 个)")
        print_case_list(cases)
        print()

if __name__ == "__main__":
    if len(sys.argv) > 1:
        cmd = sys.argv[1]
        if cmd == "list":
            lib()
        elif cmd == "search" and len(sys.argv) > 2:
            results = search_cases(sys.argv[2])
            print_case_list(results)
        else:
            print("用法: python case_library.py [list|search <关键词>]")
    else:
        lib()

#!/usr/bin/env python3
"""
🎛️ 案例选择器 (Case Selector)
=============================
用于 Hermes 对话系统的案例库交互工具

功能：
1. 查询案例库，生成格式化的选择列表
2. 解析用户的选择（编号、关键词、或不选）
3. 返回参考图路径或 None

使用方式（在 Hermes 对话中）：
    Step 1: 调用 get_selection_text(task) 获取展示文本
    Step 2: Hermes AI 展示文本，询问用户
    Step 3: 用户回复选择
    Step 4: 调用 parse_user_choice(user_reply, task) 获取图片路径
"""

import os
import sys
from pathlib import Path

AGENCY_DIR = Path.home() / ".hermes/agents/multi-agent-image"
sys.path.insert(0, str(AGENCY_DIR))

from case_library import list_cases, search_cases, get_case_image_path

def get_selection_text(task: str = None, brief: str = "") -> str:
    """
    生成供 Hermes 展示的案例选择文本

    Args:
        task: 任务类型 (poster/product/ppt/infographic/teaching)
        brief: 用户原始需求（用于智能推荐）

    Returns:
        格式化的选择文本，直接展示给用户
    """
    cases = list_cases(task)

    if not cases:
        return "📚 案例库暂无相关案例，将直接生成新图片。"

    lines = []
    lines.append("📚 案例库")
    lines.append("=" * 50)
    lines.append(f"找到 {len(cases)} 个{'相关' if task else ''}案例:\n")

    # 按评分排序
    sorted_cases = sorted(cases, key=lambda x: x.get("rating", 0), reverse=True)

    for i, case in enumerate(sorted_cases, 1):
        case_id = case.get("case_id", f"case_{i:03d}")
        brief_text = case.get("brief", "无标题")[:35]
        task_type = case.get("task", "unknown")
        rating = case.get("rating", 0)
        tags = ", ".join(case.get("tags", [])[:3])
        stars = "⭐" * int(rating) if rating else ""

        # 标记推荐（评分最高）
        recommend = " 👈 推荐" if i == 1 else ""

        lines.append(f"  [{i}] {case_id} [{task_type}]")
        lines.append(f"      {brief_text} {stars}{recommend}")
        if tags:
            lines.append(f"      🏷️  {tags}")
        lines.append("")

    # 智能推荐说明
    if brief:
        lines.append(f"💡 根据你的需求「{brief[:20]}...」，推荐选择 [{1}] 号案例作为风格参考。")
        lines.append("")

    lines.append("选项:")
    lines.append("  [1-N] 输入编号，使用该案例风格参考")
    lines.append("  [s]   搜索案例（输入关键词）")
    lines.append("  [n]   不参考案例，全新生成")
    lines.append("")
    lines.append("请回复你的选择:")

    return "\n".join(lines)

def parse_user_choice(user_reply: str, task: str = None) -> tuple:
    """
    解析用户的选择回复

    Args:
        user_reply: 用户的回复文本（如 "1"、"n"、"搜索橙色"）
        task: 任务类型

    Returns:
        (action, result)
        - action: "generate" | "search" | "skip"
        - result: 图片路径 或 搜索关键词 或 None
    """
    reply = user_reply.strip().lower()

    # 不选
    if reply in ["n", "no", "否", "不", "不用", "不需要", "直接生成", "全新"]:
        return "skip", None

    # 搜索
    if reply == "s" or "搜索" in reply:
        keyword = reply.replace("搜索", "").replace("s", "").strip()
        if not keyword:
            return "search", ""  # 需要进一步询问关键词
        results = search_cases(keyword, task)
        if results:
            return "generate", results[0].get("image_path")
        return "skip", None

    # 按编号选择
    cases = list_cases(task)
    sorted_cases = sorted(cases, key=lambda x: x.get("rating", 0), reverse=True)

    try:
        idx = int(reply) - 1
        if 0 <= idx < len(sorted_cases):
            selected = sorted_cases[idx]
            return "generate", selected.get("image_path")
    except ValueError:
        pass

    # 模糊匹配（用户可能直接说了案例编号）
    if "case_" in reply:
        case_id = [w for w in reply.split() if w.startswith("case_")][0]
        path = get_case_image_path(case_id, task)
        if path:
            return "generate", path

    # 默认不选
    return "skip", None

def get_case_preview(case_id: str, task: str = None) -> str:
    """
    获取案例预览信息（用于展示给用户）
    """
    path = get_case_image_path(case_id, task)
    if not path:
        return None

    cases = list_cases(task)
    for case in cases:
        if case.get("case_id") == case_id:
            return {
                "image_path": path,
                "brief": case.get("brief", ""),
                "rating": case.get("rating", 0),
                "tags": case.get("tags", []),
            }
    return {"image_path": path, "brief": "", "rating": 0, "tags": []}

# 测试
if __name__ == "__main__":
    print(get_selection_text("poster", "AI训练营海报"))

#!/usr/bin/env python3
"""
Internal design compiler for multi-agent-image.

This module extracts the prompt-compilation logic that was previously delegated
to an external runtime. It keeps the prompt-only path lightweight and reusable
from both CLI wrappers and Python call sites.
"""

from __future__ import annotations

from typing import Any


TASK_KEYWORDS = {
    "poster": ["海报", "poster", "封面", "主视觉", "campaign", "kv"],
    "product": ["商品", "产品", "电商", "product", "hero shot", "广告图", "首图"],
    "ppt": ["ppt", "幻灯片", "演示", "deck", "slide", "配图", "章节页"],
    "infographic": ["信息图", "infographic", "流程图", "结构图", "总结图", "overview"],
    "teaching": ["教学", "演示图", "讲解", "培训", "课件", "步骤图", "demo"],
}

DEFAULT_ASPECT = {
    "poster": "3:4",
    "product": "1:1",
    "ppt": "16:9",
    "infographic": "4:3",
    "teaching": "16:9",
}

QUALITY_MODEL = {
    "draft": "gpt-image-2",
    "final": "gpt-image-2",
    "premium": "gpt-image-2",
}

ASPECT_SIZES = {
    "1:1": {"2K": "2048x2048", "3K": "3072x3072"},
    "3:4": {"2K": "1728x2304", "3K": "2592x3456"},
    "4:3": {"2K": "2304x1728", "3K": "3456x2592"},
    "16:9": {"2K": "2848x1600", "3K": "4096x2304"},
    "9:16": {"2K": "1600x2848", "3K": "2304x4096"},
    "3:2": {"2K": "2496x1664", "3K": "3744x2496"},
    "2:3": {"2K": "1664x2496", "3K": "2496x3744"},
    "4:5": {"2K": "1840x2304", "3K": "2760x3456"},
    "5:4": {"2K": "2304x1840", "3K": "3456x2760"},
    "2:1": {"2K": "3072x1536", "3K": "4096x2048"},
    "1:2": {"2K": "1536x3072", "3K": "2048x4096"},
    "21:9": {"2K": "3360x1440", "3K": "5120x2160"},
    "9:21": {"2K": "1440x3360", "3K": "2160x5120"},
}

CORE_SOURCE_SECTIONS = [
    "## Your workflow",
    "## Output creation guidelines",
    "### How to do design work",
    "## Content Guidelines",
    "**Do not add filler content.**",
    "**Create a system up front:**",
    "**Avoid AI slop tropes:**",
]

TASK_SOURCE_SECTIONS = {
    "poster": [
        "### How to do design work",
        "## Content Guidelines",
        "**Do not add filler content.**",
    ],
    "product": [
        "## Output creation guidelines",
        "## Content Guidelines",
        "**Avoid AI slop tropes:**",
    ],
    "ppt": [
        "## Content Guidelines",
        "**Create a system up front:**",
        "**Use appropriate scales:**",
    ],
    "infographic": [
        "## Content Guidelines",
        "**Do not add filler content.**",
        "**Avoid AI slop tropes:**",
    ],
    "teaching": [
        "## Content Guidelines",
        "**Do not add filler content.**",
        "**Use appropriate scales:**",
    ],
}

DIRECTION_PROFILES = {
    "conservative": {
        "style_bias": "restrained, cleaner, corporate, polished, lower-risk",
        "energy_bias": "controlled, composed, authoritative",
        "composition_bias": "cleaner geometry, more negative space, lower background complexity",
        "palette_bias": "restricted palette with restrained accents",
        "detail_bias": "cleaner surfaces, less decorative detail",
    },
    "balanced": {
        "style_bias": "premium editorial, contemporary, polished, commercially strong",
        "energy_bias": "energetic but disciplined, confident, professional",
        "composition_bias": "clear hierarchy, dynamic but stable layout, deliberate focal contrast",
        "palette_bias": "premium neutrals with one strong accent family",
        "detail_bias": "hero-detail emphasis with a restrained background",
    },
    "bold": {
        "style_bias": "larger scale, more dramatic, more surprising, high-contrast",
        "energy_bias": "ambitious, high-energy, assertive, vivid",
        "composition_bias": "bolder crop, stronger scale contrast, more motion cues, still disciplined",
        "palette_bias": "higher-contrast palette with strong accent energy",
        "detail_bias": "high-impact hero detail, expressive texture, controlled spectacle",
    },
}

GLOBAL_DIRECTIVES = [
    "Start from purpose, audience, and channel rather than surface-level adjectives.",
    "Create a coherent visual system before detailing the image.",
    "Use one clear hero idea and preserve obvious hierarchy.",
    "Treat negative space and safe zones as design decisions, not leftover space.",
    "Avoid filler content, decorative noise, and meaningless visual data.",
    "Respect existing brand or context when available; if not, still commit to a clear direction.",
    "Avoid AI-slop tropes such as random HUD overlays, generic fog, empty gradients, and scattered floating debris.",
]

TASK_PROFILES = {
    "poster": {
        "communication_goal": "attract and persuade quickly in a campaign or recruitment context",
        "hero_strategy": "one dominant hero visual or symbolic concept, never a collage of equal-weight objects",
        "safe_zone": "reserve a clean, obvious text-safe zone in the upper third or one side for headline and CTA copy",
        "lighting": "crisp premium lighting with controlled contrast and energetic highlights",
        "palette": "restricted premium palette with disciplined neutrals and one energetic accent family",
        "detail_density": "hero-rich detail with restrained background complexity",
        "base_style": "editorial campaign key visual",
        "task_constraints": [
            "make the result feel campaign-ready rather than generic AI art",
            "prioritize focal hierarchy and typography-safe composition",
        ],
        "task_avoid": [
            "poster text rendered directly into the image unless explicitly requested",
            "random marketing icons and decorative interface fragments",
        ],
    },
    "product": {
        "communication_goal": "make the product feel desirable, premium, and commercially credible",
        "hero_strategy": "the product is the undisputed focal point with clear silhouette and edge readability",
        "safe_zone": "keep surrounding space supportive and uncluttered so the product remains dominant",
        "lighting": "commercial lighting that reveals material, finish, and shape without cheap reflections",
        "palette": "palette chosen to support product positioning rather than compete with the product",
        "detail_density": "high fidelity on the hero object, restrained props and background",
        "base_style": "high-end commercial product advertising",
        "task_constraints": [
            "preserve product proportions and perceived material integrity",
            "use props only when they reinforce product positioning",
        ],
        "task_avoid": [
            "oversized props stealing attention",
            "luxury claims paired with cheap lighting or noisy backgrounds",
        ],
    },
    "ppt": {
        "communication_goal": "support presentation storytelling with a clear, memorable visual metaphor",
        "hero_strategy": "a single strong metaphor or scene readable at presentation distance",
        "safe_zone": "reserve a large clean area for slide title and subtitle overlay",
        "lighting": "clean, legible lighting that supports shape readability over moodiness",
        "palette": "presentation-friendly palette with strong contrast and limited visual noise",
        "detail_density": "mid-detail image readable at a glance, not overloaded with tiny elements",
        "base_style": "presentation cover art",
        "task_constraints": [
            "favor readability from distance over excess detail",
            "keep enough room for future title placement",
        ],
        "task_avoid": [
            "ad-poster density",
            "tiny embedded text or fragile detail that disappears on slides",
        ],
    },
    "infographic": {
        "communication_goal": "communicate structure, grouping, and flow rather than literal dense data",
        "hero_strategy": "clear modular hierarchy with one dominant organizing principle",
        "safe_zone": "leave room for headings or labels without relying on the model to render tiny text",
        "lighting": "flat-to-controlled lighting that supports structure and clarity",
        "palette": "structured palette with clear grouping and low noise",
        "detail_density": "low-to-mid detail, with emphasis on grouping and directional logic",
        "base_style": "structured infographic-like visual system",
        "task_constraints": [
            "prioritize visual structure over fake data richness",
            "use symbolic clarity and modular composition",
        ],
        "task_avoid": [
            "tiny chart labels",
            "data slop, fake dashboards, and dense unreadable micro-details",
        ],
    },
    "teaching": {
        "communication_goal": "explain a process, comparison, or sequence with maximum clarity",
        "hero_strategy": "show the logic of the teaching point first, then add supporting visuals",
        "safe_zone": "keep panel or label areas simple and legible for later annotation",
        "lighting": "clear explanatory lighting, not overly cinematic",
        "palette": "clarity-first palette with simple grouping and controlled contrast",
        "detail_density": "mid-to-low detail with emphasis on readable sequence and large forms",
        "base_style": "instructional visual storytelling",
        "task_constraints": [
            "make sequence and cause-effect legible at first glance",
            "use big forms and obvious directional logic",
        ],
        "task_avoid": [
            "cinematic clutter that weakens explanation",
            "too many simultaneous steps in one frame",
        ],
    },
}


def detect_task(brief: str) -> str:
    text = brief.lower()
    scores: dict[str, int] = {}
    for task, keywords in TASK_KEYWORDS.items():
        scores[task] = sum(1 for keyword in keywords if keyword.lower() in text)
    best_task = max(scores, key=scores.get)
    return best_task if scores[best_task] > 0 else "poster"


def normalize_task(task: str, brief: str) -> str:
    return detect_task(brief) if task == "auto" else task


def choose_model(quality: str) -> str:
    return QUALITY_MODEL[quality]


def choose_size(task: str, aspect: str, quality: str) -> str:
    tier = "2K" if quality == "draft" or task in {"ppt", "infographic", "teaching"} else "3K"
    aspect_sizes = ASPECT_SIZES.get(aspect)
    if aspect_sizes:
        return aspect_sizes[tier]
    return ASPECT_SIZES[DEFAULT_ASPECT[task]][tier]


def join_phrases(items: list[str]) -> str:
    return "; ".join(item for item in items if item)


def unique_preserving_order(items: list[str]) -> list[str]:
    seen: set[str] = set()
    ordered: list[str] = []
    for item in items:
        if item not in seen:
            seen.add(item)
            ordered.append(item)
    return ordered


def make_design_reasoning(
    *,
    brief: str,
    task: str,
    direction: str,
    audience: str | None = None,
    usage: str | None = None,
    brand: str | None = None,
    style: str | None = None,
    mood: str | None = None,
    goal: str | None = None,
    composition: str | None = None,
    constraints: str | None = None,
    avoid: str | None = None,
    safe_zone: str | None = None,
    lighting: str | None = None,
    palette: str | None = None,
    image: list[str] | None = None,
) -> dict[str, Any]:
    profile = TASK_PROFILES[task]
    direction_profile = DIRECTION_PROFILES[direction]

    brand_strategy = (
        f"use the provided brand/context: {brand}"
        if brand
        else "no explicit brand provided; commit to one coherent visual system instead of averaging styles"
    )

    reference_strategy = (
        "use provided reference images to preserve consistency and context"
        if image
        else "no reference images provided; rely on the compiled visual system and brief"
    )

    source_sections = unique_preserving_order(CORE_SOURCE_SECTIONS + TASK_SOURCE_SECTIONS[task])

    visual_system = [
        f"base mode: {profile['base_style']}",
        f"direction bias: {direction_profile['style_bias']}",
        f"energy bias: {direction_profile['energy_bias']}",
        f"composition bias: {direction_profile['composition_bias']}",
        f"palette bias: {direction_profile['palette_bias']}",
    ]

    hierarchy_strategy = [
        "one clear hero idea",
        profile["hero_strategy"],
        "secondary elements must support the hero rather than compete with it",
        "background should create rhythm, not narrative confusion",
    ]

    anti_filler_rules = [
        "every element must earn its place",
        "do not add objects, labels, icons, or stats that do not strengthen the core message",
        "if the frame feels empty, solve with scale, crop, rhythm, or texture rather than random extra elements",
    ]

    anti_slop_rules = [
        "avoid generic AI clutter",
        "avoid random floating UI fragments or HUD overlays",
        "avoid generic gradient fog with no composition logic",
        "avoid cheap neon cyberpunk treatment unless explicitly requested",
        "avoid noisy micro-detail that weakens the hierarchy",
    ]

    if avoid:
        anti_slop_rules.append(avoid)

    return {
        "task": task,
        "direction": direction,
        "communication_goal": goal or profile["communication_goal"],
        "audience": audience or "broad professional audience",
        "channel": usage or task,
        "brief": brief.strip(),
        "brand_strategy": brand_strategy,
        "reference_strategy": reference_strategy,
        "visual_system": visual_system,
        "hierarchy_strategy": hierarchy_strategy,
        "safe_zone_strategy": safe_zone or profile["safe_zone"],
        "lighting_strategy": lighting or profile["lighting"],
        "palette_strategy": palette or profile["palette"],
        "detail_density": direction_profile["detail_bias"] + "; " + profile["detail_density"],
        "style_direction": style or join_phrases(visual_system),
        "mood_direction": mood or direction_profile["energy_bias"],
        "composition_logic": composition or direction_profile["composition_bias"],
        "anti_filler_rules": anti_filler_rules,
        "anti_slop_rules": anti_slop_rules,
        "task_constraints": profile["task_constraints"] + ([constraints] if constraints else []),
        "task_avoid": profile["task_avoid"],
        "global_directives": GLOBAL_DIRECTIVES,
        "source_sections": source_sections,
        "primary_source_file": "internal:multi-agent-image/scripts/design_compiler.py",
    }


def compile_design_brief(reasoning: dict[str, Any], aspect: str) -> dict[str, Any]:
    return {
        "task": reasoning["task"],
        "direction": reasoning["direction"],
        "brief": reasoning["brief"],
        "communication_goal": reasoning["communication_goal"],
        "audience": reasoning["audience"],
        "channel": reasoning["channel"],
        "brand_strategy": reasoning["brand_strategy"],
        "reference_strategy": reasoning["reference_strategy"],
        "visual_system": join_phrases(reasoning["visual_system"]),
        "hierarchy": join_phrases(reasoning["hierarchy_strategy"]),
        "composition": reasoning["composition_logic"],
        "safe_zone": reasoning["safe_zone_strategy"],
        "lighting": reasoning["lighting_strategy"],
        "palette": reasoning["palette_strategy"],
        "detail_density": reasoning["detail_density"],
        "style_direction": reasoning["style_direction"],
        "mood": reasoning["mood_direction"],
        "constraints": join_phrases(reasoning["task_constraints"]),
        "avoid": join_phrases(reasoning["anti_slop_rules"] + reasoning["task_avoid"]),
        "aspect": aspect,
        "source_sections": reasoning["source_sections"],
    }


def build_prompt(brief: dict[str, Any]) -> str:
    parts = [
        f"Create a {brief['task']} image for {brief['channel']} aimed at {brief['audience']}.",
        f"Treat this as a design-led visual solving this brief: {brief['brief']}.",
        f"Communication goal: {brief['communication_goal']}.",
        "Translate the brief into one strong hero concept rather than many equal-weight elements.",
        f"Brand and context strategy: {brief['brand_strategy']}.",
        f"Visual system: {brief['visual_system']}.",
        f"Hierarchy: {brief['hierarchy']}.",
        f"Composition: {brief['composition']}.",
        f"Safe zone: {brief['safe_zone']}.",
        f"Lighting: {brief['lighting']}.",
        f"Color strategy: {brief['palette']}.",
        f"Detail density: {brief['detail_density']}.",
        f"Style direction: {brief['style_direction']}.",
        f"Mood: {brief['mood']}.",
        f"Aspect ratio: {brief['aspect']}.",
        f"Important constraints: {brief['constraints']}.",
        f"Avoid: {brief['avoid']}.",
        "Emphasize strong hierarchy, intentional whitespace, disciplined background complexity, and polished professional finish.",
    ]
    return " ".join(parts)


def compile_prompt_package(
    *,
    brief: str,
    task: str = "auto",
    direction: str = "balanced",
    aspect: str | None = None,
    quality: str = "final",
    audience: str | None = None,
    usage: str | None = None,
    brand: str | None = None,
    style: str | None = None,
    mood: str | None = None,
    goal: str | None = None,
    composition: str | None = None,
    constraints: str | None = None,
    avoid: str | None = None,
    safe_zone: str | None = None,
    lighting: str | None = None,
    palette: str | None = None,
    image: list[str] | None = None,
    model_override: str | None = None,
) -> dict[str, Any]:
    normalized_task = normalize_task(task, brief)
    resolved_aspect = aspect or DEFAULT_ASPECT[normalized_task]
    design_reasoning = make_design_reasoning(
        brief=brief,
        task=normalized_task,
        direction=direction,
        audience=audience,
        usage=usage,
        brand=brand,
        style=style,
        mood=mood,
        goal=goal,
        composition=composition,
        constraints=constraints,
        avoid=avoid,
        safe_zone=safe_zone,
        lighting=lighting,
        palette=palette,
        image=image,
    )
    compiled_brief = compile_design_brief(design_reasoning, resolved_aspect)
    prompt = build_prompt(compiled_brief)
    model = model_override or choose_model(quality)
    size = choose_size(normalized_task, resolved_aspect, quality)

    return {
        "design_reasoning": design_reasoning,
        "compiled_brief": compiled_brief,
        "prompt": prompt,
        "settings": {
            "model": model,
            "size": size,
            "aspect": resolved_aspect,
            "direction": direction,
            "quality": quality,
        },
    }

#!/usr/bin/env python3
"""
Standalone design compiler for multi-agent-image.

It keeps the original prompt-compilation workflow available locally while using
the repo's own GPT-Image-2 runtime instead of an external generator.
"""

from __future__ import annotations

import argparse
import json
import sys
from pathlib import Path

from design_compiler import compile_prompt_package
from gpt_image2_generator import generate_image


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Compile a design-led image brief and optionally generate with GPT-Image-2."
    )
    parser.add_argument("--task", default="auto", choices=["auto", "poster", "product", "ppt", "infographic", "teaching"])
    parser.add_argument("--brief", required=True, help="User brief or request")
    parser.add_argument("--audience", default=None, help="Target audience")
    parser.add_argument("--usage", default=None, help="Where the image will be used")
    parser.add_argument("--brand", default=None, help="Brand tone or reference context")
    parser.add_argument("--style", default=None, help="Preferred visual style override")
    parser.add_argument("--mood", default=None, help="Preferred mood override")
    parser.add_argument("--goal", default=None, help="Specific communication goal override")
    parser.add_argument("--composition", default=None, help="Composition override")
    parser.add_argument("--constraints", default=None, help="Must-have constraints")
    parser.add_argument("--avoid", default=None, help="Things to avoid")
    parser.add_argument("--aspect", default=None, help="Aspect ratio such as 1:1, 3:4, 16:9")
    parser.add_argument("--direction", default="balanced", choices=["conservative", "balanced", "bold"])
    parser.add_argument("--safe-zone", default=None, help="Safe-zone strategy override")
    parser.add_argument("--lighting", default=None, help="Lighting strategy override")
    parser.add_argument("--palette", default=None, help="Palette strategy override")
    parser.add_argument("--quality", default="final", choices=["draft", "final", "premium"])
    parser.add_argument("--model-override", default=None, help="Explicit model id override")
    parser.add_argument("--image", nargs="+", default=None, help="Reference image path(s) or URL(s)")
    parser.add_argument("--output", "-o", default=None, help="Output filename")
    parser.add_argument("--output-dir", default=None, help="Output directory")
    parser.add_argument("--prompt-only", action="store_true", help="Only print design reasoning, compiled brief, and the final prompt")
    return parser.parse_args()


def print_package(package: dict) -> None:
    print("[design_reasoning]")
    print(json.dumps(package["design_reasoning"], ensure_ascii=False, indent=2))
    print("\n[compiled_brief]")
    print(json.dumps(package["compiled_brief"], ensure_ascii=False, indent=2))
    print("\n[prompt]")
    print(package["prompt"])

    settings = package["settings"]
    print(
        "\n[settings]\n"
        f"model={settings['model']}\n"
        f"size={settings['size']}\n"
        f"aspect={settings['aspect']}\n"
        f"direction={settings['direction']}\n"
        f"quality={settings['quality']}"
    )


def main() -> int:
    args = parse_args()
    package = compile_prompt_package(
        brief=args.brief,
        task=args.task,
        direction=args.direction,
        aspect=args.aspect,
        quality=args.quality,
        audience=args.audience,
        usage=args.usage,
        brand=args.brand,
        style=args.style,
        mood=args.mood,
        goal=args.goal,
        composition=args.composition,
        constraints=args.constraints,
        avoid=args.avoid,
        safe_zone=args.safe_zone,
        lighting=args.lighting,
        palette=args.palette,
        image=args.image,
        model_override=args.model_override,
    )
    print_package(package)
    sys.stdout.flush()

    if args.prompt_only:
        return 0

    save_dir = args.output_dir
    if args.output:
        output_path = Path(args.output)
        if output_path.parent != Path("."):
            save_dir = str(output_path.parent)

    result = generate_image(
        prompt=package["prompt"],
        size=package["settings"]["aspect"],
        save_dir=save_dir,
    )
    if result.get("status") == "success" and args.output:
        target_dir = Path(save_dir) if save_dir else Path(result["filepath"]).parent
        target_path = target_dir / Path(args.output).name
        Path(result["filepath"]).replace(target_path)
        result["filepath"] = str(target_path)
        result["filename"] = target_path.name

    print("\n[result]")
    print(json.dumps(result, ensure_ascii=False, indent=2))
    return 0 if result.get("status") == "success" else 1


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env python3
"""
GPT-Image-2 图片生成器 (apimart.ai)
支持异步任务提交和轮询查询
"""

import os
import json
import time
import requests
from datetime import datetime
from pathlib import Path

API_BASE = "https://api.apimart.ai/v1"

def require_api_key(api_key: str = None) -> str:
    """Return the apimart/OpenAI-compatible API key or fail with a clear message."""
    resolved = api_key or os.environ.get("OPENAI_API_KEY")
    if not resolved:
        raise RuntimeError(
            "Missing OPENAI_API_KEY. Set your apimart.ai GPT-Image-2 key before generating images."
        )
    return resolved

def submit_task(prompt: str, size: str = "1:1", api_key: str = None):
    """
    提交图片生成任务
    
    Args:
        prompt: 图片描述
        size: 图片比例 - "1:1", "16:9", "9:16", "4:3", "3:4", etc.
        api_key: API Key
    
    Returns:
        dict: 包含 task_id
    """
    api_key = require_api_key(api_key)
    
    url = f"{API_BASE}/images/generations"
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
    data = {
        "model": "gpt-image-2",
        "prompt": prompt,
        "n": 1,
        "size": size
    }
    
    print(f"   📤 提交任务...")
    print(f"   📝 Prompt: {prompt[:60]}...")
    print(f"   📐 Size: {size}")
    
    response = requests.post(url, headers=headers, json=data, timeout=30)
    response.raise_for_status()
    
    result = response.json()
    
    if result.get("code") == 200:
        task_id = result["data"][0]["task_id"]
        print(f"   ✅ 任务已提交: {task_id}")
        return {"success": True, "task_id": task_id}
    else:
        error_msg = result.get("error", {}).get("message", "Unknown error")
        print(f"   ❌ 提交失败: {error_msg}")
        return {"success": False, "error": error_msg}

def query_task(task_id: str, api_key: str = None):
    """
    查询任务状态
    
    Returns:
        dict: 任务状态和结果
    """
    api_key = require_api_key(api_key)
    
    url = f"{API_BASE}/tasks/{task_id}"
    headers = {"Authorization": f"Bearer {api_key}"}
    
    response = requests.get(url, headers=headers, timeout=30)
    response.raise_for_status()
    
    return response.json()

def wait_for_completion(task_id: str, api_key: str = None, 
                        initial_delay: int = 10, poll_interval: int = 5, 
                        max_wait: int = 120):
    """
    轮询等待任务完成
    
    Args:
        task_id: 任务ID
        api_key: API Key
        initial_delay: 首次查询前的等待时间（秒）
        poll_interval: 轮询间隔（秒）
        max_wait: 最大等待时间（秒）
    
    Returns:
        dict: 任务结果
    """
    print(f"\n   ⏳ 等待生成完成（首次等待 {initial_delay}s）...")
    time.sleep(initial_delay)
    
    start_time = time.time()
    attempts = 0
    
    while time.time() - start_time < max_wait:
        attempts += 1
        elapsed = int(time.time() - start_time)
        
        print(f"   🔄 第 {attempts} 次查询（已等待 {elapsed}s）...", end=" ")
        
        result = query_task(task_id, api_key)
        
        if result.get("code") != 200:
            error_msg = result.get("error", {}).get("message", "Query failed")
            print(f"❌ 查询错误: {error_msg}")
            return {"success": False, "error": error_msg}
        
        task_data = result["data"]
        status = task_data.get("status")
        progress = task_data.get("progress", 0)
        
        if status == "completed":
            print(f"✅ 完成!")
            return {"success": True, "data": task_data}
        elif status == "failed":
            error_msg = task_data.get("error", {}).get("message", "Task failed")
            print(f"❌ 失败: {error_msg}")
            return {"success": False, "error": error_msg}
        elif status in ["pending", "processing"]:
            print(f"⏳ {status} ({progress}%)")
            time.sleep(poll_interval)
        else:
            print(f"❓ 未知状态: {status}")
            time.sleep(poll_interval)
    
    print(f"\n   ⏰ 超时（超过 {max_wait}s）")
    return {"success": False, "error": "Timeout"}

def download_image(image_url: str, save_path: str):
    """下载图片到本地"""
    print(f"   📥 下载图片...")
    
    response = requests.get(image_url, timeout=60)
    response.raise_for_status()
    
    with open(save_path, 'wb') as f:
        f.write(response.content)
    
    file_size = os.path.getsize(save_path) / 1024
    print(f"   ✅ 已保存: {save_path} ({file_size:.1f} KB)")
    
    return save_path

def generate_image(prompt: str, size: str = "1:1", save_dir: str = None, 
                   api_key: str = None):
    """
    完整的图片生成流程（提交 + 轮询 + 下载）
    
    Returns:
        dict: 完整的生成结果
    """
    if save_dir is None:
        save_dir = os.path.expanduser("~/.hermes/agents/multi-agent-image/output")

    os.makedirs(save_dir, exist_ok=True)
    api_key = require_api_key(api_key)

    # 1. 提交任务
    submit_result = submit_task(prompt, size, api_key)
    if not submit_result["success"]:
        return {"status": "failed", "error": submit_result.get("error")}
    
    task_id = submit_result["task_id"]
    
    # 2. 等待完成
    wait_result = wait_for_completion(task_id, api_key)
    if not wait_result["success"]:
        return {"status": "failed", "error": wait_result.get("error")}
    
    task_data = wait_result["data"]
    
    # 3. 提取图片 URL
    images = task_data.get("result", {}).get("images", [])
    if not images or not images[0].get("url"):
        return {"status": "failed", "error": "No image URL in result"}
    
    image_url = images[0]["url"][0]
    expires_at = images[0].get("expires_at")
    
    # 4. 下载图片
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    safe_name = "".join(c if c.isalnum() else "_" for c in prompt[:20])
    filename = f"{timestamp}_{safe_name}.png"
    filepath = os.path.join(save_dir, filename)
    
    download_image(image_url, filepath)
    
    return {
        "status": "success",
        "filepath": filepath,
        "filename": filename,
        "image_url": image_url,
        "task_id": task_id,
        "generation_info": {
            "model": "gpt-image-2",
            "prompt": prompt,
            "size": size,
            "actual_time": task_data.get("actual_time"),
            "estimated_time": task_data.get("estimated_time"),
            "created": task_data.get("created"),
            "completed": task_data.get("completed"),
            "expires_at": expires_at
        }
    }

def main():
    """命令行入口"""
    import sys
    
    if len(sys.argv) < 2:
        print("Usage: python gpt_image2_generator.py 'prompt' [size]")
        print("Example: python gpt_image2_generator.py 'a cyberpunk cat' 16:9")
        sys.exit(1)
    
    prompt = sys.argv[1]
    size = sys.argv[2] if len(sys.argv) > 2 else "1:1"
    
    result = generate_image(prompt, size)
    print("\n" + "="*50)
    print(json.dumps(result, indent=2, ensure_ascii=False))

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
🚀 Multi-Agent Image — Install Script
=============================================
One-command deployment from skill directory to runtime working directory.

Usage:
    python3 ~/.hermes/skills/multi-agent-image/scripts/install.py

What it does:
1. Copies all Python scripts to ~/.hermes/agents/multi-agent-image/
2. Creates agent role directories if missing
3. Prints next steps
"""

import os
import shutil
import sys
from pathlib import Path

SKILL_DIR = Path.home() / ".hermes/skills/multi-agent-image"
AGENCY_DIR = Path.home() / ".hermes/agents/multi-agent-image"

def install():
    print("=" * 50)
    print("Multi-Agent Image — Install")
    print("=" * 50)

    # 2. Create directories
    AGENCY_DIR.mkdir(parents=True, exist_ok=True)
    for subdir in ["prompt_engineer", "style_scout", "image_generator",
                   "qa_bot", "metadata_manager", "refiner", "tools", "output"]:
        (AGENCY_DIR / subdir).mkdir(exist_ok=True)
    print(f"✅ Working directory ready: {AGENCY_DIR}")

    # 3. Copy scripts
    src_scripts = SKILL_DIR / "scripts"
    copied = 0
    for f in src_scripts.glob("*.py"):
        if f.name == "install.py":
            continue
        dst = AGENCY_DIR / f.name
        shutil.copy2(f, dst)
        copied += 1
    print(f"✅ Copied {copied} scripts to {AGENCY_DIR}")

    # 4. Copy agent roles (optional — only if memory.json doesn't exist yet)
    src_roles = SKILL_DIR / "references" / "agents"
    role_map = {
        "prompt_engineer.md": "prompt_engineer/role.md",
        "style_scout.md": "style_scout/role.md",
        "image_generator.md": "image_generator/role.md",
        "qa_bot.md": "qa_bot/role.md",
        "metadata_manager.md": "metadata_manager/role.md",
    }
    for src_name, dst_path in role_map.items():
        src = src_roles / src_name
        dst = AGENCY_DIR / dst_path
        if src.exists() and not dst.exists():
            shutil.copy2(src, dst)
            print(f"✅ Copied role: {dst_path}")

    # 5. Create empty memory.json files if missing
    for agent in ["prompt_engineer", "style_scout", "image_generator", "qa_bot", "metadata_manager", "refiner"]:
        mem = AGENCY_DIR / agent / "memory.json"
        if not mem.exists():
            mem.write_text("{}")

    print("\n" + "=" * 50)
    print("🎉 Install complete!")
    print("=" * 50)
    print(f"\nNext steps:")
    print(f"  1. Set API key: export OPENAI_API_KEY=sk-...")
    print(f"  2. Test the local compiler: cd {AGENCY_DIR} && python3 design_image.py --brief 'AI训练营招生海报' --prompt-only")
    print(f"  3. Or use orchestrator: python3 -c \"from orchestrator_v2 import run; run('test')\"")
    print(f"\nRuntime output dir: {AGENCY_DIR / 'output'}")
    print(f"Case library dir:   {AGENCY_DIR / 'case_library'}")

if __name__ == "__main__":
    install()