手机原图
 → 
AI去杂物
 → 
AI风格化(3种)
 → 
拼接对比图
 → 
生成GIF
 → 
AI写推文
 → 
待发布

=== 独立工程（各有各的 Git 仓库）===
# Filesystem MCP Server（Anthropic 官方维护，已验证可用）
# 安装方式：npx -y @modelcontextprotocol/server-filesystem <允许目录>
# 提供 14 个 Tools：read_file, write_file, edit_file, 
#   list_directory, search_files, get_file_info, ...
# 传输方式：stdio（标准输入输出）
# === OpenClaw Skills — 两个目录，不同用途 ===
~/.openclaw/workspace/skills/             ← "重型" Skills（带脚本的业务流水线）
├── auto-twitter-campaign/                ← 本文主角：图片处理 + 文案生成
│   ├── SKILL.md
│   └── scripts/
│       ├── campaign.py                   ← 编排器
│       └── batch_compare.py              ← 图像处理流水线
├── ming-flash-omni/                      ← 单图交互 Skill
├── stock-analysis/                       ← 股票分析
└── x-trends-nvdfx/                       ← Twitter 趋势
~/.openclaw/skills/                       ← "轻型" Skills（MCP 的使用说明书）
├── filesystem/                           ← 教 Agent 怎么用 Filesystem MCP
│   ├── skill.json
│   └── prompt.md
└── wechat/                               ← 教 Agent 怎么用微信键盘模拟
    ├── skill.json
    ├── prompt.md
    └── scripts/send_message.sh 等
# === MCP 注册配置 ===
~/.claude.json → mcpServers               ← 告诉 Agent 每个 MCP Server 怎么启动
# === 业务数据 ===
~/campaign_images/
├── images/new/                           ← 待处理原图（输入）
├── candidates/                           ← 中间产物
└── results/                              ← 最终产出（对比图/GIF/推文）

┌─────────────────────────────────┐
│           Monolithic Agent       │
│                                 │
│  ┌───────────────────────────┐  │
│  │   巨大的 System Prompt     │  │
│  │   (所有知识 + 所有指令)     │  │
│  └───────────────────────────┘  │
│  ┌───────────────────────────┐  │
│  │   硬编码的工具调用逻辑      │  │
│  └───────────────────────────┘  │
│  ┌───────────────────────────┐  │
│  │   自定义 API 集成          │  │
│  └───────────────────────────┘  │
└─────────────────────────────────┘

# ❌ 单体 Agent 方案 — 反模式示例
# 一个 3000 行的 monolithic_agent.py
SYSTEM_PROMPT = """
你是一个图片编辑助手。你需要：
1. 扫描图片中的游客、车辆、栏杆等杂物
2. 用 Ming-flash-omni-2.0 模型进行 inpainting 去除
3. 生成3种风格变体：氛围/戏剧/艺术
4. 用 Pillow 拼接对比图
5. 生成 GIF 动画
6. 写 Twitter 推文（格式：📍地点 📅时间 🏔️场景...）
7. 写小红书文案（格式：标题+正文+标签）
8. 通过 Zenmux API 发送请求，endpoint 是 https://zenmux.ai/api/vertex-ai
9. 图片压缩到 2MB 以内，最大边 2048px
10. 评分标准：结构保持30分 + 清理质量25分 + 无幻觉25分 + 视觉质量20分
... (还有 200 行指令)
"""
# 所有函数都在一个文件里
defanalyze_cleanup(image): ...
defedit_image(image, instruction): ...
defscore_image(orig, edited): ...
defanalyze_styles(image): ...
defmake_comparison(orig, edited): ...
defmake_gif(images): ...
defgenerate_tweet(images, desc): ...
defpost_to_twitter(tweet, media): ...      # 直接硬编码 Twitter API
defpost_to_xiaohongshu(text, images): ...  # 直接硬编码小红书 API
defsend_wechat_notification(msg): ...      # 直接硬编码微信 API
defmain():
    # 一个 main 函数串联所有逻辑，无法复用
    images = scan_pending()
    for img in images:
        cleaned = cleanup(img)
        styles = stylize(cleaned)
        comparison = stitch(img, styles)
        gif = animate(comparison)
        tweet = write_tweet(comparison)
        post_to_twitter(tweet, gif)         # 紧耦合
        post_to_xiaohongshu(tweet, gif)     # 紧耦合
        send_wechat_notification("Done!")   # 紧耦合

my-skill/
├── SKILL.md          ← 主文件：YAML 元数据 + Markdown 指令
├── scripts/
│   ├── deploy.sh     ← 可执行脚本
│   └── validate.py
├── templates/
│   └── config.yaml   ← 模板资源
└── docs/
    └── reference.md  ← 参考文档

---
name: auto-twitter-campaign
description: Autonomous AI image campaign content generator. Processes pending
  photos via Ming-flash-omni-2.0 (cleanup + style editing), creates side-by-side
  comparison images and GIF showcases, then auto-generates tweet text using AI.
---

## Quick Start
python3 {baseDir}/scripts/campaign.py run
python3 {baseDir}/scripts/campaign.py process
python3 {baseDir}/scripts/campaign.py showcase --description "大年初四唐乾陵"
## Pipeline
1. Cleanup Director → 2. Cleanup Creator → 3. Style Director
→ 4. Style Creator → 5. Showcase → 6. Tweet Writer

# scripts/batch_compare.py 中的具体实现代码
# Agent 直接执行 python3 命令，不需要理解内部逻辑

# === Director（导演）：决定做什么 ===
defanalyze_cleanup(client, image_data):
    """扫描图片，识别杂物，输出一条清理指令"""
    prompt = (
        "You are an expert photo retoucher. Your job is to find EVERY "
        "non-natural element... Look for: People, vehicles, barriers..."
    )
    # 返回: "Repaint the silver car on the right with clean ground"
    # 或:   "NONE"
# === Creator（执行者）：生成候选方案 ===
defedit_image(client, image_data, instruction, is_cleanup=False):
    """根据指令生成编辑后的图片"""
    # cleanup 模式: inpainting 去杂物
    # style 模式: 风格迁移
    # 每次调用生成 1 张，循环 3 次生成 3 个候选
# === Critic（评审员）：打分选优 ===
defscore_image(client, orig_data, edit_data, instruction):
    """对比原图和编辑图，按 4 个维度打分 0-100"""
    # 结构保持 (30分) + 清理质量 (25分)
    # + 无幻觉 (25分) + 视觉质量 (20分)

Director (分析 Prompt)  →  "去除右侧三个游客"
         │
Creator ×3 (编辑 Prompt)  →  3 个候选图
         │
Critic (评分 Prompt)  →  "候选2最佳，85分"

# campaign.py — 薄编排层，不包含业务逻辑
defcmd_process(args):
    """动态导入 batch_compare.py 并执行"""
    spec = importlib.util.spec_from_file_location(
        "batch_compare", SCRIPT_DIR / "batch_compare.py"
    )
    mod = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(mod)
    mod.main()  # 全部业务逻辑在 Skill 的脚本中
defcmd_showcase(args):
    """GIF 生成 + AI 写推文"""
    generate_gifs(results_dir)       # Pillow 处理
    generate_tweet_text(results_dir)  # Ming API 调用
defcmd_run(args):
    """完整流水线 = process + showcase"""
    cmd_process(args)   # Stage 1: 图片处理
    cmd_showcase(args)  # Stage 2: 展示 + 文案

┌──────────────┐     JSON-RPC2.0      ┌──────────────┐
│  MCPClient  │ ◄──────────────────► │  MCPServer  │
│  (AI 应用)    │   StreamableHTTP     │  (外部服务)   │
└──────────────┘                       └──────────────┘
       │                                      │
  Claude/GPT/                           GitHubAPI
  Gemini 等                             数据库/
                                        文件系统等

// ~/.claude.json 中的 MCP 配置
{
  "mcpServers":{
    "filesystem":{
      "command":"npx",
      "args":["-y","@modelcontextprotocol/server-filesystem","~/campaign_images"],
      "type":"stdio"
    }
  }
}   "command":"npx",      "args":["-y","@modelcontextprotocol/server-filesystem","~/campaign_images"],      "type":"stdio"    }  }}

# 1. MCP 握手 — 成功
$ echo'{"jsonrpc":"2.0","id":1,"method":"initialize",...}' \
  | npx -y @modelcontextprotocol/server-filesystem ~/campaign_images
→ {"serverInfo":{"name":"secure-filesystem-server","version":"0.2.0"}}
# 2. 工具发现 — 14 个 Tools
→ read_file, read_text_file, read_media_file, read_multiple_files,
  write_file, edit_file, create_directory, list_directory,
  list_directory_with_sizes, directory_tree, move_file,
  search_files, get_file_info, list_allowed_directories
# 3. list_directory — 列出 pose 编辑结果
$ tools/call list_directory {"path":"~/campaign_images/results/pose"}
→ [FILE] pose_微信图片_20260226155545_1_248_rank1.jpg
  [FILE] pose_微信图片_20260226155545_1_248_rank2.jpg
  [FILE] pose_微信图片_20260226155545_1_248_grid.jpg
  ...
# 4. get_file_info — 查询文件元数据
$ tools/call get_file_info {"path":"...rank1.jpg"}
→ size: 218451, permissions: 644, isFile: true
# 5. search_files — 搜索所有 prompts 文件
$ tools/call search_files {"path":"...results/pose","pattern":"*prompts*"}
→ pose_IMG_6382_prompts.txt
  pose_微信图片_20260226155545_1_248_prompts.txt

auto-twitter-campaign/
├── SKILL.md          ← Agent 接口
└── scripts/
    ├── campaign.py   ← 自包含的 Python 脚本
    └── batch_compare.py

filesystem/
├── skill.json        ← Skill 元数据（触发条件）
└── prompt.md         ← "怎么使用 Filesystem MCP"的说明
wechat/
├── skill.json
├── prompt.md         ← "怎么使用微信键盘模拟"的说明
└── scripts/
    ├── send_message.sh   ← 简单的 shell 包装
    ├── read_chat.sh
    └── list_contacts.sh

Skill: filesystem/prompt.md
  "当用户想查看处理结果时，先通过 MCP 的 list_directory 列出文件，
   然后用 search_files 搜索特定模式的文件，
   再用 get_file_info 获取文件大小和修改时间..."
         │
         ▼ Agent 按照 Skill 指令行动
         │
MCP Server: filesystem (stdio)
  server.tool("list_directory", {path})
  server.tool("search_files", {path, pattern})

┌─────────────────────────────────────────┐
│              OpenClaw 架构               │
│                                         │
│  Gateway─── 消息平台连接层              │
│    │         (WhatsApp/Telegram/Discord  │
│    │          + 可桥接扩展其他平台)       │
│    ▼                                    │
│  Agent──── 推理引擎（理解用户意图）      │
│    │                                    │
│    ▼                                    │
│  Skills─── 模块化能力扩展               │
│    │         (3000+ 社区 Skills)         │
│    ▼                                    │
│  Memory─── 持久化存储层                 │
│              (上下文 + 偏好)              │
└─────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────┐
│              完整生产架构                                  │
│                                                         │
│  用户入口：                                              │
│  ┌──────┐  ┌──────────┐  ┌───────┐  ┌──────┐          │
│  │ 微信  │  │微信(桥接) │  │Telegram│  │CLI  │          │
│  └──┬───┘  └──┬───────┘  └───┬───┘  └──┬───┘          │
│     │      bridge_openclaw.py │         │               │
│     │      (轮询+转发)        │         │               │
│     └─────────┴──────────────┴─────────┘                │
│                    │                                    │
│              OpenClawGateway                           │
│              (localhost:18789)                           │
│                    │                                    │
│              OpenClawAgent                             │
│              (KimiK2.5 推理引擎)                       │
│                    │                                    │
│     ┌──────────────┼──────────────┐                     │
│     ▼              ▼              ▼                     │
│  ┌────────┐  ┌──────────┐  ┌──────────┐               │
│  │Skills│  │   MCP    │  │  Memory  │               │
│  └────┬───┘  └────┬─────┘  └──────────┘               │
│       │           │                                    │
│  ┌────┴────────────┴────────────────┐                  │
│  │                                  │                  │
│  │  Skill: auto-twitter-campaign    │                  │
│  │  ├ campaign.py (编排)            │                  │
│  │  └ batch_compare.py (处理)       │                  │
│  │                                  │                  │
│  │  Skill: ming-flash-omni          │                  │
│  │  └ ming_image.py (单图交互)      │                  │
│  │                                  │                  │
│  │  MCP: filesystem                   │                  │
│  │  └ stdio → 文件读写/搜索/列表     │                  │
│  │                                  │                  │
│  │  Skill: wechat-bridge              │                  │

1. Gateway 收到 微信 消息
   └→ Agent 推理引擎解析意图: "处理照片 + 生成文案"

2. Agent 扫描 Skill 元数据
   └→ 匹配 auto-twitter-campaign（description 包含 "process pending images"）

3. Agent 加载 SKILL.md Level 2 指令
   └→ 发现命令: python3 scripts/campaign.py run --description "大年初四唐乾陵"

4. Agent 执行 Skill 脚本
   └→ batch_compare.py Stage 1: 清理
      ├→ Director: analyze_cleanup() → "去除前景三个游客和右侧金属栏杆"
      ├→ Creator ×3: edit_image() → 3个清理候选
      └→ Critic: score_image() → 选出 85 分的最佳候选
   └→ batch_compare.py Stage 2: 风格化
      ├→ Style Director: analyze_3styles() → 秋日暖色/夕阳/水墨
      └→ Creator ×3: 每种风格各生成 1 张
   └→ campaign.py showcase:
      ├→ 拼接 compare_*.jpg → make_comparison()
      ├→ 生成 showcase_all.gif → make_gif()
      └→ AI 写推文 → generate_tweet_text()

5. Agent 通过 MCP:filesystem 读取 results/ 目录
   └→ 列出新生成的对比图和 GIF 文件

6. Agent 通过微信桥接脚本发通知
   └→ "唐乾陵照片处理完成 ✓"

 A2A（横向：Agent 间协作）
Agent A ◄─────────────────────► Agent B
  │                                │
  │ MCP（纵向：连接工具）           │ MCP
  ▼                                ▼
Tools/Data                    Tools/Data

┌─────────────────────────────────────────────────────┐
│                  2026 Agentic AI 协议栈               │
│                                                     │
│  ┌───────────────────────────────────────────────┐  │
│  │  应用层：OpenClaw / Claude Code / Cursor       │  │
│  │         (Agent 运行环境)                       │  │
│  └───────────────────┬───────────────────────────┘  │
│                      │                              │
│  ┌──────────┐  ┌─────┴─────┐  ┌──────────────────┐ │
│  │  Skills   │  │   Agent   │  │      A2A         │ │
│  │ (知识层)  │  │  (推理层)  │  │ (Agent间协作层)  │ │
│  │ 教怎么做  │  │  决定做什么 │  │  跨Agent委派     │ │
│  └──────────┘  └─────┬─────┘  └──────────────────┘ │
│                      │                              │
│  ┌───────────────────┴───────────────────────────┐  │
│  │              MCP (工具连接层)                    │  │
│  │         连接数据库/API/文件系统/SaaS             │  │
│  └───────────────────────────────────────────────┘  │
│                                                     │
│  ┌───────────────────────────────────────────────┐  │
│  │           基础设施：LLM API / 本地模型           │  │
│  └───────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────┘

用户在微信发送"处理照片 xxx.jpg"
  → AI 处理图片（清理+风格编辑+对比图+GIF）
  → AI 生成推文文案
  → 将结果汇报回微信

demo_case1.py (Python 硬编码)
  ├── open_chat_once("dandan")          ← wechat_mcp 键盘模拟打开聊天
  ├── send_in_current_chat("收到...")    ← 剪贴板粘贴+回车
  ├── subprocess: campaign.py run       ← 子进程执行图片处理
  ├── count 新增 compare_* 文件         ← 修改时间差集
  ├── send_in_current_chat("完成...")    ← 固定模板回复
  └── send_in_current_chat("推文:...")   ← 读取 tweet.txt 回复

# 问题：每次 send() 都重新搜索 "dandan"，导致消息发到错误窗口
# 解决：open_chat_once() 只在首次打开，后续复用已打开的窗口
_chat_opened = False
defopen_chat_once():
    """只在第一次打开聊天窗口，之后复用"""
    global _chat_opened
    ifnot _chat_opened:
        from wechat_mcp.wechat_keyboard import open_chat_via_keyboard
        open_chat_via_keyboard(CHAT_NAME)
        time.sleep(0.5)
        # Escape 确保焦点离开搜索框
        subprocess.run(["osascript", "-e",
            'tell application "System Events" to key code 53'], timeout=5)
        time.sleep(0.3)
        _chat_opened = True
defsend_in_current_chat(msg: str):
    """在已打开的聊天窗口中直接发送消息（不重新搜索）"""
    from wechat_mcp.wechat_keyboard import _activate_wechat, _set_clipboard, _run_applescript
    _activate_wechat()
    time.sleep(0.2)
    _set_clipboard(msg)
    _run_applescript(
        'tell application "System Events" to tell process "WeChat" '
        'to keystroke "v" using command down'
    )
    time.sleep(0.3)
    _run_applescript(
        'tell application "System Events" to tell process "WeChat" '
        'to key code 36'
    )
    time.sleep(0.3)

# 问题：同名文件被覆盖时，Path 集合差集为空，显示"新增 0 张"
# 解决：记录处理前每个文件的 mtime，处理后比对
# 处理前
existing_results = {p: p.stat().st_mtime for p in RESULTS_DIR.glob("compare_*")}
# 处理后
new_results = sum(1 for p in RESULTS_DIR.glob("compare_*")
                 if p not in existing_results or p.stat().st_mtime > existing_results[p])

# 回复内容是硬编码的格式化字符串，无 AI 参与
send(f"图片处理完成！新增 {new_results} 张对比图")
send(f"处理完成！结果汇总:\n- 对比图: {len(compares)}张\n- GIF展示: {len(gifs)}个")
tweet_preview = tweet_text[:300] + ("..."iflen(tweet_text) > 300else"")
send(f"推文文案:\n{tweet_preview}")

bridge_openclaw.py (轮询 + 转发)
  ├── read_chat("dandan")                ← 截图OCR读取微信消息
  ├── is_actionable(msg)?                ← 简单噪音过滤（长度、黑名单）
  ├── send_wechat("收到，正在处理...")     ← 确认回复
  │
  ├── openclaw agent --message "处理照片 xxx.jpg" --json
  │     │
  │     └── Kimi K2.5 推理引擎
  │           ├── 扫描 12 个 Skill 的元数据
  │           ├── 匹配 auto-twitter-campaign（语义理解）
  │           ├── 读取 SKILL.md Level 2 指令
  │           ├── 执行: python3 campaign.py run --image xxx.jpg
  │           └── 组织回复（Markdown 表格 + emoji + 文件列表）
  │
  └── send_wechat(agent_reply)           ← 转发 Agent 回复

defcall_openclaw_agent(message: str, timeout: int = 600) -> str | None:
    """调用 OpenClaw Agent 处理消息，返回 agent 的回复文本。"""
    env = os.environ.copy()  # 传递 ZENMUX_API_KEY 等环境变量
    result = subprocess.run(
        ["openclaw", "agent", "--agent", "main",
         "--message", message,
         "--json", "--timeout", str(timeout)],
        capture_output=True, text=True, timeout=timeout + 30,
        env=env
    )
    data = json.loads(result.stdout)
    # gateway 模式: result.payloads[].text
    payloads = data.get("result", data).get("payloads", [])
    texts = [p["text"] for p in payloads if p.get("text")]
    return"\n".join(texts) if texts elseNone

defis_actionable(msg: str) -> bool:
    """判断消息是否值得交给 Agent 处理（过滤噪音）。"""
    msg = msg.strip()
    iflen(msg) < 2:
        returnFalse
    noise = {"你好", "好的", "谢谢", "ok", "OK", "嗯", "哦", "收到"}
    if msg in noise:
        returnFalse
    # 过滤 agent 自己的回复（避免循环）
    if msg.startswith(("Agent ", "[OpenClaw]", "收到指令", "执行完成")):
        returnFalse
    returnTrue
    # 注意：不需要 parse_command()，Agent 自己理解意图

def poll_loop(chat_name: str, interval: int, once: bool = False):
    state = load_state()
    while True:
        messages = read_chat(chat_name)
        current_hash = messages_hash(messages)
        if current_hash != state["last_hash"] and messages:
            latest = messages[-1]
            if is_actionable(latest) and latest not in state["processed"]:
                send_wechat(chat_name, f"收到，正在处理: {latest[:50]}...")
                reply = call_openclaw_agent(latest)  # ← 核心：交给 Agent
                if reply:
                    for chunk in split_message(reply, max_len=500):
                        send_wechat(chat_name, chunk)
                state["processed"].append(latest)
            state["last_hash"] = current_hash
            save_state(state)
        if once:
            break
        time.sleep(interval)

============================================================
Case 1 Demo: 微信驱动的图片营销闭环
============================================================
[状态] pending/ 待处理: 15 张
[状态] results/ 已有对比图: 24 张
[微信] 发送: 收到指令：处理照片 正在处理: 20260219085128_1_14.jpg 请稍候...
[Step 3+4] 处理图片 + 生成展示和推文...
[微信] 发送: 图片处理完成！新增 9 张对比图...
[微信] 发送: 处理完成！结果汇总: - 对比图: 24张 - GIF展示: 7个 ...
[微信] 发送: 推文文案: 📍 Mount Hua (华山) — The Perilous Plank Walk...

[15:20:33] [微信→] 收到，正在处理: 处理照片 20260219085132_2_14.jpg...
[15:20:41] [OpenClaw] 发送给 Agent: 处理照片 20260219085132_2_14.jpg...
[15:21:02] [OpenClaw] Agent 回复: 照片 `20260219085132_2_14.jpg` **已处理完成** ✅
**生成的文件：**
| 文件 | 大小 | 说明 |
|------|------|------|
| compare_20260219085132_2_14_v1.jpg | ... | 原图 vs AI编辑对比 |
...
⚙️ Engine: Ming-flash-omni-2.0
On the first day of the lunar new year...
[15:21:05] [微信→] 照片 `20260219085132_2_14.jpg` **已处理完成** ✅ ...

┌──────────────────────────────────────┐
│         demo_case1.py                │
│                                      │
│  1. open_chat_once()      ← 微信 IO │
│  2. send_in_current_chat() ← 微信 IO │
│  3. subprocess(campaign.py) ← 业务  │
│  4. count_files()          ← 业务    │
│  5. send_in_current_chat() ← 微信 IO │
│                                      │
│  所有逻辑在一个脚本中，              │
│  编写时确定，运行时不变              │
└──────────────────────────────────────┘

┌──────────────────────────────────────┐
│       bridge_openclaw.py             │
│       (轻薄桥接层，~150 行)           │
│                                      │
│  1. read_chat()      ← 微信输入      │
│  2. is_actionable()  ← 噪音过滤      │
│  3. openclaw agent   ← 交给 Agent    │
│  4. send_wechat()    ← 微信输出      │
│                                      │
│  不包含任何业务逻辑                   │
└───────────┬──────────────────────────┘
            │
            ▼
┌──────────────────────────────────────┐
│       OpenClaw Agent(Kimi K2.5)     │
│                                      │
│  1. 理解自然语言意图                  │
│  2. 扫描 Skill 元数据（12个）         │
│  3. 匹配 auto-twitter-campaign       │
│  4. 读取 SKILL.md 指令               │
│  5. 执行 campaign.py                 │
│  6. 组织回复文本                      │
│                                      │
│  运行时 AI 决策，行为可变             │
└──────────────────────────────────────┘

Claude 方案:  demo_case1.py = 微信IO + 业务编排 + 结果格式化 (170行，厚桥接)
OpenClaw 方案: bridge_openclaw.py = 微信IO + 转发 (160行，薄桥接)方案: bridge_openclaw.py = 微信IO + 转发 (160行，薄桥接)

~/.openclaw/skills/wechat-bridge/scripts/
├── demo_case1.py           ←Claude 方案：确定性高、延迟低、适合关键路径
├── bridge_openclaw.py      ←OpenClaw 方案：灵活性高、可扩展、适合通用入口
└── bridge.py               ← 原始版本：硬编码流程（已被上述两者取代）

用例A → Agent A（包含所有知识和工具）
用例B → Agent B（重复造轮子）
用例C → Agent C（又一个单体）

                    ┌── Skill: 部署
通用 Agent 引擎 ────┼── Skill: 代码审查
                    ├── Skill: 数据分析
                    └── Skill: 客户支持l: 代码审查                    ├── Skill: 数据分析                    └── Skill: 客户支持