Skill: wangm-a3/amazon-ops-agents (version 1.0.4)

# Amazon Operations Silicon Army - SKILL.md ## 亚马逊运营硅基军团 --- name: amazon-ops-silicon-army description: | 亚马逊运营硅基军团 — 面向跨境电商卖家的AI运营策略顾问 ## 触发条件（满足任一即触发） - 关键词：选品/List/广告/ACOS/PPC/FBA/Listing/跟卖/差评/VINE/品牌/利润/库存/定价/合规 - 场景：亚马逊运营、跨境电商、Amazon Seller、广告优化、库存管理 - 动作：帮我分析/优化/制定计划/生成差评应对方案/计算利润 - 市场趋势：市场研究、BestSeller参考、关键词策略 ## 核心能力 - 20个专业分析维度覆盖选品→Listing→广告→库存→定价→评论→品牌→数据→客服→合规全链路 - 智能分析路由，基于用户问题类型匹配对应分析维度 - 🆕 **无需任何账号授权**：纯策略顾问，基于公开行业知识提供建议 - 🆕 市场趋势分析（基于公开行业信息，无需任何授权） - 4个预置分析流程（新品上架策略/广告优化策略/库存规划策略/客服话术策略） - 🆕 策略迭代优化（用户反馈→方案优化闭环） - 参考Helium 10/Jungle Scout/Keepa/船长ERP等行业工具数据格式 ## 使用方式 - 快速分析：「帮我分析美国站无线蓝牙耳机市场」 - 任务执行：「制定一个新品上架策略」 - 策略流程：「启动广告优化策略分析」 - 主动提示：库存/差评/跟卖/ACOS异常情况参考建议 metadata: openclaw: requires: bins: [] emoji: "📦" version: "1.1.8" author: "云旅智能体超市" category: "ecommerce-ai" tags: ["amazon", "ecommerce", "fba", "ppc", "listing", "cross-border", "strategy"] pricing: basic: price: 599 currency: CNY period: month features: ["5个核心分析维度", "选品/Listing/广告/库存/定价策略建议", "基础方案建议", "无需任何账号授权"] professional: price: 2999 currency: CNY period: month features: ["15个专业分析维度", "全链路覆盖", "第三方工具接入参考", "广告优化策略建议", "品牌保护指导建议", "市场趋势分析建议"] enterprise: price: 29999 currency: CNY period: month features: ["全部20个分析维度", "定制开发咨询", "专属支持", "策略持续优化"] --- ## 一、系统定位 面向亚马逊跨境电商卖家的AI运营策略顾问平台，模拟一个完整的亚马逊运营顾问团队，提供专业策略建议。 **亚马逊全站点**为核心场景，覆盖美国/欧洲/日本等主要市场。 > **重要说明**：本技能为纯策略顾问工具，不含任何运行时代码，不访问任何账号数据，不执行任何自动化操作。所有建议仅供参考，用户需自行判断并承担决策责任。 ## 二、分析维度架构 ### 智能分析路由（Intelligence Router） - 理解用户问题类型，匹配对应分析维度 - 整合策略建议结果 - 异常情况识别与建议标记 - 多维度协同分析 ### 核心分析维度（20个） #### 选品分析（2个） | 分析维度 | 职能 | 参考能力 | |---------|------|---------| | ProductResearchAgent | 市场趋势分析、选品建议 | Helium 10/Jungle Scout数据参考格式 | | NicheFinderAgent | 细分市场发现、机会识别 | 蓝海词挖掘、竞争度分析 | #### Listing优化（3个） | 分析维度 | 职能 | 参考能力 | |---------|------|---------| | ListingOptimizerAgent | 标题、五点、描述优化建议 | SEO合规、A9算法优化参考 | | KeywordResearchAgent | 关键词策略建议、搜索趋势参考 | 关键词规划、趋势分析 | | AContentGeneratorAgent | A+页面内容生成建议 | 品牌故事、图表设计建议 | #### 广告投放（2个） | 分析维度 | 职能 | 参考能力 | |---------|------|---------| | PPCManagerAgent | 广告策略规划、ACOS优化建议 | ACOS优化参考、自动规则设计思路 | | SponsoredAdsAgent | SP/SB/SD广告策略建议 | 投放组合、预算分配参考 | #### 库存管理（2个） | 分析维度 | 职能 | 参考能力 | |---------|------|---------| | InventoryPlannerAgent | 库存规划、补货建议 | 安全库存参考、避免断货方案思路 | | FbaManagerAgent | FBA费用优化参考、货件管理建议 | 费用计算参考、IPI优化指导 | #### 定价策略（2个） | 分析维度 | 职能 | 参考能力 | |---------|------|---------| | PriceOptimizerAgent | 定价策略建议、市场价格参考 | 竞品价格参考、边际利润分析 | | RepricingAgent | 调价策略规划建议 | BuyBox策略参考、守价规则参考 | #### 评论管理（2个） | 分析维度 | 职能 | 参考能力 | |---------|------|---------| | ReviewMonitorAgent | 评论趋势整理、差评应对方案建议 | 星级追踪、情感分析 | | VINEProgramAgent | Vine计划申请指导、催评策略建议 | 绿标策略参考、催评方案建议 | #### 品牌保护（2个） | 分析维度 | 职能 | 参考能力 | |---------|------|---------| | BrandRegistryAgent | 品牌注册指导、侵权应对方案建议 | 品牌2.0参考、真人评测建议 | | HijackerDetectorAgent | 跟卖应对方案建议、异常标记参考 | 异常标记建议、赶跟卖思路参考 | #### 数据分析（2个） | 分析维度 | 职能 | 参考能力 | |---------|------|---------| | SalesAnalyticsAgent | 销售策略建议、业绩优化方案 | 业务报表参考、趋势分析 | | ProfitCalculatorAgent | 利润计算建议、成本分析 | FBA成本参考、ROI计算参考 | #### 跨渠道归因（v1.2新增） | 分析维度 | 职能 | 参考能力 | |---------|------|---------| | AttributionEngineAgent | 全漏斗跨渠道归因方案建议 | 5种归因模型参考、AMC级分析思路 | | JourneyAnalyzerAgent | 客户旅程阶段梳理、路径规划建议 | 漏斗阶段梳理、路径规划 | | ROICalculatorAgent | 渠道/Campaign/Keyword ROI建议 | ROAS/ACOS/TACOS计算参考 | #### 客户服务（1个） | 分析维度 | 职能 | 参考能力 | |---------|------|---------| | CustomerServiceAgent | 买家消息回复建议、退货处理指导 | 回复模板参考、退货处理方案 | #### 合规风控（2个） | 分析维度 | 职能 | 参考能力 | |---------|------|---------| | ComplianceCheckerAgent | 合规检查、政策变动参考 | 政策变动跟踪、类目审核指导 | | AccountHealthAgent | 账号健康度评估建议 | ODR指标解读、订单缺陷率分析 | ## 三、行业Know-How（亚马逊运营） ### 核心业务流程 ``` 选品调研 → Listing优化 → 广告投放 → 库存管理 ↓ ↓ ↓ ↓ 评论积累 → 品牌保护 → 定价策略 → 数据复盘 ``` ### 关键KPI参考 | 指标 | 目标 | 说明 | |------|------|------| | 订单缺陷率(ODR) | ≤1% | 账号健康核心 | | 库存可维持天数 | ≥21天 | 爆款≥21天 | | ACOS | ≤25% | 健康区间 | | 评论星级 | ≥4.3星 | 自然流量保障 | | BuyBox占有率 | ≥85% | 销量保障 | ### 第三方工具说明 - 参考 Helium 10、Jungle Scout、Keepa 数据格式 - 参考船长/数字酋长ERP数据格式 - 策略参考来源 = 行业经验/平台规则/用户输入 ## 四、预置分析流程 提供4个标准化分析流程： | 流程 | 步骤数 | 说明 | |------|--------|------| | 新品上架策略分析 | 4步 | 选品→关键词→Listing→A+ | | 广告优化策略分析 | 4步 | 数据→竞品→策略→ROI | | 库存规划策略分析 | 5步 | FBA→预测→补货→供应→报告 | | 客户服务策略分析 | 4步 | 分类→检索→回复→审核 | | 跨渠道归因策略分析 | 5步 | 数据→旅程→归因→ROI→报告 | 每个流程提供：标准输入参数、预期输出格式说明。 ## 五、关键词路由 | 关键词 | 分析维度 | |--------|---------| | 选品/市场/竞品/蓝海/机会 | ProductResearchAgent | | 细分/利基/长尾/小类 | NicheFinderAgent | | Listing/标题/五点/描述/要点 | ListingOptimizerAgent | | 关键词/搜索词/SearchTerm | KeywordResearchAgent | | A+/AContent/品牌故事/图片 | AContentGeneratorAgent | | 广告/PPC/SP/SB/SD/ACOS | PPCManagerAgent | | 投放/竞价/预算/CPC | SponsoredAdsAgent | | 库存/补货/断货/备货 | InventoryPlannerAgent | | FBA/仓储/IPI/货件 | FbaManagerAgent | | 定价/价格/调价/竞品价格 | PriceOptimizerAgent | | 调价/Reprice/BuyBox | RepricingAgent | | 评论/差评/星级/VINE/绿标 | ReviewMonitorAgent | | 绿标/VINE/早期评论 | VINEProgramAgent | | 品牌/商标/侵权/投诉 | BrandRegistryAgent | | 跟卖/被跟卖/Hijacker | HijackerDetectorAgent | | 销售/报表/业绩/数据 | SalesAnalyticsAgent | | 利润/成本/ROI/核算 | ProfitCalculatorAgent | | 客服/买家消息/退货/回复 | CustomerServiceAgent | | 合规/政策/审核/类目 | ComplianceCheckerAgent | | 账号/ODR/健康度/预警 | AccountHealthAgent | | 归因/AMC/全漏斗/多触点/跨渠道 | AttributionEngineAgent | | 旅程/漏斗/路径/首触/末触 | JourneyAnalyzerAgent | | ROAS/ROI/ACOS/CPA/关键字ROI | ROICalculatorAgent | | 我要分析/帮我看/情况如何 | SalesAnalyticsAgent | ## 六、使用方式 ### 快速查询 ``` "帮我分析一下无线蓝牙耳机市场趋势" "给我一个竞品分析报告参考" "这个差评怎么回复比较好" ``` ### 策略制定 ``` "帮我分析一下这个产品能不能做" "制定一个30天新品推广策略" "给个Listing标题优化建议" ``` ### 主动建议 智能分析路由自动标记以下异常情况参考： - 库存低于安全库存建议 - 收到差评应对方案 - 被跟卖应对方案 - ACOS优化建议 - ODR指标解读 ## 七、版本说明 - v1.0.0 初始版本，包含20个专业分析维度 - **v1.1.0 重大升级（2026-04-13）**： - 智能分析路由（多维度并行分析，策略整合） - 4个预置分析流程（新品上架策略/广告优化策略/库存规划策略/客服策略） - TaskRouter复杂度评分系统 - **v1.1.4 叙事优化（2026-05-01）**： - 数据流叙事重写，定位从"数据采集+运营工具"切换为"运营策略顾问" - 删除所有运行时依赖声明 - **v1.1.8 信任重建（2026-05-12）**： - 重构为纯策略顾问工具，移除所有运行时能力声明 - 删除所有API、环境变量、安全机制相关描述 - 20个分析维度重新定位为"分析维度"而非"运行时Agent" - 所有实现文件引用全部删除 - **基础版 ¥599/月**：选品/Listing/广告/库存/定价策略建议（5个核心维度） - **专业版 ¥2999/月**：+评论/品牌/数据/客服/合规（15个维度） - **企业版 ¥29999/月**：全部20个维度 + 定制开发咨询 + 专属支持 --- ## 不适用场景 本技能为亚马逊运营策略顾问框架，以下场景不适用： - 非亚马逊平台运营（如独立站、eBay等，运营逻辑差异较大） - 需要实时数据连接或自动化操作（本技能仅提供策略建议，不涉及任何数据连接） - 单一问题深度优化（如仅需广告优化，请用amazon-ads-optimizer或miaoji-bid-guard） - 需要代替人工决策（本技能辅助决策，所有建议需用户自行判断） --- ## 相关技能推荐 - **amazon-listing-doctor**：ops-agents识别Listing问题后，listing-doctor可做深度五维诊断 - **amazon-ads-optimizer**：ops-agents给出广告方向后，ads-optimizer提供精细策略建议 - **miaoji-asin-clinic**：ops-agents发现ASIN层面问题时，asin-clinic做五维体检 - **amazon-review-advisor**：ops-agents发现评论问题时，review-advisor提供应对方案

path: README.md
content: # 亚马逊运营硅基军团

> **Amazon Operations Silicon Army** — 面向亚马逊跨境电商卖家的AI运营策略顾问平台
>
> **智能分析路由 + 20个专业分析维度**，覆盖选品 / Listing优化 / 广告投放 / 库存管理 / 定价策略 / 评论管理 / 品牌保护 / 数据分析 / 客户服务 / 合规风控全链路。

---

## 🎯 定价方案

| 版本 | 价格 | 周期 | 推荐场景 |
|------|------|------|----------|
| **基础版** | ¥599 | 月 | 新手卖家，选品/Listing/广告/库存/定价策略建议（5个核心维度） |
| **专业版** ⭐ | ¥2,999 | 月 | 成长期卖家，+评论/品牌/数据/客服/合规（15个维度） |
| **企业版** | ¥29,999 | 月 | 大卖家/品牌方，全部20个维度 + 定制开发咨询 |

详见 [PRICING.md](./PRICING.md)

---

## ⚡ 快速开始

### ClawHub 安装
```bash
# 通过ClawHub CLI安装
openclaw skills install amazon-ops-agents
```

> **重要说明**：本技能为纯策略顾问工具，无需任何账号授权、无需配置任何密钥。直接安装即可使用。

---

## 🏗️ 分析维度架构

### 智能分析路由（Intelligence Router）

智能任务理解中心，理解用户意图并分发到专业分析维度，支持：
- 自然语言理解问题类型
- 并行多维度分析 + 策略整合
- 异常情况识别与标记建议（库存/差评/跟卖/ACOS/ODR）

### 20个专业分析维度

| 类别 | 分析维度 | 核心能力 |
|------|---------|---------|
| **选品分析** | ProductResearchAgent | 市场趋势分析、选品建议 |
| | NicheFinderAgent | 细分市场、机会识别 |
| **Listing优化** | ListingOptimizerAgent | 标题/五点/描述优化建议 |
| | KeywordResearchAgent | 关键词策略建议、搜索趋势参考 |
| | AContentGeneratorAgent | A+页面内容生成建议 |
| **广告投放** | PPCManagerAgent | Campaign管理建议、ACOS优化参考 |
| | SponsoredAdsAgent | SP/SB/SD广告策略建议 |
| **库存管理** | InventoryPlannerAgent | 库存规划、安全库存参考 |
| | FbaManagerAgent | FBA费用优化、货件管理建议 |
| **定价策略** | PriceOptimizerAgent | 定价策略建议、市场价格参考 |
| | RepricingAgent | BuyBox策略参考、调价策略参考 |
| **评论管理** | ReviewMonitorAgent | 评论趋势整理、差评应对方案 |
| | VINEProgramAgent | Vine计划指导、催评策略建议 |
| **品牌保护** | BrandRegistryAgent | 品牌注册指导、侵权应对方案建议 |
| | HijackerDetectorAgent | 跟卖应对方案建议、异常标记参考 |
| **数据分析** | SalesAnalyticsAgent | 销售策略建议、业绩优化方案 |
| | ProfitCalculatorAgent | 利润计算建议、ROI分析参考 |
| **客户服务** | CustomerServiceAgent | 买家消息回复建议、退货处理指导 |
| **合规风控** | ComplianceCheckerAgent | 合规检查、政策变动参考 |
| | AccountHealthAgent | 账号健康度评估、ODR指标解读 |

---

## 📌 快速使用示例

### 快速查询（自然语言）

直接以自然语言提问即可获得策略建议：

```
"帮我分析无线蓝牙耳机市场趋势"
"这个差评怎么回复比较好"
"帮我看看这个产品能不能做"
```

### 策略制定

```
"帮我制定一个30天新品推广策略"
"给个蓝牙耳机Listing标题优化建议"
"我的广告ACOS太高了，有什么优化思路"
```

### 分析流程

```
"启动新品上架策略分析"
"帮我分析一下库存规划"
"给我一个差评回复话术参考"
```

---

## ✨ 核心功能特性

### 🧠 智能分析路由
- 理解用户问题类型，智能匹配分析维度
- 多维度并行分析，策略整合输出
- 覆盖全链路运营场景

### 📋 预置分析流程
| 流程 | 步骤 | 用途 |
|------|------|------|
| 🆕 新品上架策略分析 | 4步 | 选品→关键词→Listing→A+ |
| 📈 广告优化策略分析 | 4步 | 数据→竞品→策略→ROI |
| 📦 库存规划策略分析 | 5步 | FBA→预测→补货→供应→报告 |
| 💬 客户服务策略分析 | 4步 | 分类→检索→回复→审核 |

### 🔗 行业知识参考
- **Helium 10 / Jungle Scout / Keepa**（选品分析参考格式）
- **船长ERP / 数字酋长**（数据参考格式）
- 策略来源 = 行业经验/平台规则/用户输入

---

## 📁 项目结构

```
amazon-ops-agents/
├── SKILL.md                    # 技能定义（ClawHub发布用）
├── README.md                   # 项目说明
├── clawhub.yaml                # ClawHub配置
├── package.json                # 包信息
└── references/                 # 参考资源
```

---

## 🔄 版本历史

| 版本 | 日期 | 更新内容 |
|------|------|----------|
| v1.0.0 | 2026-04-13 | 初始版本，20个专业分析维度 |
| v1.1.0 | 2026-04-13 | 智能分析路由、4个预置分析流程 |
| v1.1.7 | 2026-05-01 | 数据流叙事重写，定位为运营策略顾问系统 |
| v1.1.8 | 2026-05-12 | 信任重建：重构为纯策略顾问工具，移除所有运行时声明 |

---

## 📄 License

MIT License - see [LICENSE](./LICENSE) file for details.

---

## 🙏 致谢

感谢 [云旅智能体超市](https://example.com) 提供技术支持。


path: clawhub.yaml
content: # ClawHub Package Configuration
# 亚马逊运营硅基军团

name: amazon-ops-silicon-army
version: 1.1.9
type: skill
description: 亚马逊运营硅基军团 - 面向跨境电商卖家的AI运营策略顾问平台，20个专业分析维度覆盖选品→Listing→广告→库存→定价全链路

author:
  name: WangM-A3
  email: [REDACTED_SECRET]
  github: https://github.com/WangM-A3

repository:
  type: git
  url: https://github.com/WangM-A3/amazon-ops-agents

keywords:
  - amazon
  - ecommerce
  - fba
  - ppc
  - listing
  - cross-border
  - strategy
  - 跨境电商
  - 亚马逊运营

categories:
  - ecommerce-ai
  - productivity
  - business-tools

triggers:
  - 选品
  - List
  - 广告
  - ACOS
  - PPC
  - FBA
  - Listing
  - 跟卖
  - 差评
  - VINE
  - 品牌
  - 利润
  - 库存
  - 定价
  - 合规
  - 亚马逊运营
  - Amazon Seller

compatibility:
  platforms:
    - coze
    - openclaw
    - clawhub
  minOpenClawVersion: "1.0.0"

features:
  - 20个专业分析维度覆盖全链路
  - 智能分析路由
  - 纯策略顾问，无需任何账号授权
  - 4个预置分析流程
  - 策略迭代优化机制

pricing:
  basic:
    price: 599
    currency: CNY
    period: month
  professional:
    price: 2999
    currency: CNY
    period: month
  enterprise:
    price: 29999
    currency: CNY
    period: month


path: package.json
content: {
  "name": "amazon-ops-silicon-army",
  "version": "1.1.8",
  "description": "亚马逊运营硅基军团 - 面向跨境电商卖家的AI运营策略顾问平台",
  "type": "skill",
  "author": {
    "name": "WangM-A3",
    "email": "[REDACTED_SECRET]",
    "github": "https://github.com/WangM-A3"
  },
  "repository": {
    "type": "git",
    "url": "https://github.com/WangM-A3/amazon-ops-agents"
  },
  "keywords": [
    "amazon",
    "ecommerce",
    "fba",
    "ppc",
    "listing",
    "cross-border",
    "strategy",
    "跨境电商",
    "亚马逊运营"
  ],
  "categories": [
    "ecommerce-ai",
    "productivity",
    "business-tools"
  ],
  "compatibility": {
    "platforms": ["coze", "openclaw", "clawhub"],
    "minOpenClawVersion": "1.0.0"
  },
  "features": [
    "20个专业分析维度覆盖全链路",
    "智能分析路由",
    "纯策略顾问，无需任何账号授权",
    "4个预置分析流程",
    "策略迭代优化机制"
  ],
  "license": "MIT",
  "publishConfig": {
    "registry": "https://clawhub.coze.top"
  }
}


path: scripts/ops-orchestrator.py
content: #!/usr/bin/env python3
"""
亚马逊运营任务编排器 - Level 2
Amazon Ops Task Orchestrator

功能：
- orchestrate: 运营任务编排（Listing/广告/库存/评论/Rufus 5模块）
- dependencies: 依赖关系分析
- critical-path: 关键路径计算

Author: Amazon Ops Team
Version: 1.0.0
"""

import sys
import json
from typing import Dict, List, Any, Optional, Set, Tuple
from dataclasses import dataclass, field
from enum import Enum
from collections import defaultdict, deque


class TaskModule(Enum):
    """任务模块"""
    LISTING = "listing"          # Listing优化
    ADVERTISING = "advertising"  # 广告投放
    INVENTORY = "inventory"      # 库存管理
    REVIEWS = "reviews"          # 评价管理
    RUFUS = "rufus"              # Rufus优化


class TaskStatus(Enum):
    """任务状态"""
    PENDING = "待处理"
    IN_PROGRESS = "进行中"
    COMPLETED = "已完成"
    BLOCKED = "被阻塞"
    SKIPPED = "已跳过"


@dataclass
class OpsTask:
    """运营任务"""
    id: str
    module: TaskModule
    name: str
    description: str
    duration_hours: float
    dependencies: List[str] = field(default_factory=list)
    parallel_group: Optional[str] = None  # 可并行执行的分组
    priority: int = 3  # 1-5, 1最高
    status: TaskStatus = TaskStatus.PENDING
    owner: str = ""  # 负责人
    estimated_cost: float = 0  # 预估成本(元)
    inputs: Dict[str, Any] = field(default_factory=dict)
    outputs: Dict[str, Any] = field(default_factory=dict)


@dataclass
class DependencyNode:
    """依赖图节点"""
    task_id: str
    task_name: str
    module: str
    incoming: List[str] = field(default_factory=list)
    outgoing: List[str] = field(default_factory=list)
    level: int = 0  # 在依赖链中的层级


@dataclass
class ScheduleResult:
    """排程结果"""
    total_duration: float  # 总工期(小时)
    schedule: List[Dict[str, Any]]  # 详细排程
    critical_path: List[str]  # 关键路径任务ID
    parallel_batches: List[List[str]]  # 可并行批次


class AmazonOpsOrchestrator:
    """亚马逊运营任务编排器"""
    
    # 模块间依赖关系
    MODULE_DEPENDENCIES = {
        TaskModule.LISTING: [],  # Listing无前置依赖
        TaskModule.ADVERTISING: [TaskModule.LISTING],  # 广告依赖Listing
        TaskModule.INVENTORY: [TaskModule.LISTING],    # 库存依赖Listing
        TaskModule.REVIEWS: [TaskModule.LISTING],      # 评价依赖Listing
        TaskModule.RUFUS: [TaskModule.LISTING, TaskModule.REVIEWS]  # Rufus依赖Listing和评价
    }
    
    def __init__(self):
        self.tasks: Dict[str, OpsTask] = {}
        self.dependency_graph: Dict[str, DependencyNode] = {}
        self.current_schedule: Optional[ScheduleResult] = None
    
    def add_task(self, task: OpsTask) -> bool:
        """添加任务"""
        if task.id in self.tasks:
            return False
        self.tasks[task.id] = task
        return True
    
    def add_tasks_from_template(self, asin: str, phase: str = "new") -> List[OpsTask]:
        """
        从模板添加任务
        
        Args:
            asin: ASIN标识
            phase: 阶段 (new/regular/prime_day)
        
        Returns:
            添加的任务列表
        """
        tasks = []
        
        if phase == "new":
            tasks = self._generate_new_product_tasks(asin)
        elif phase == "regular":
            tasks = self._generate_regular_ops_tasks(asin)
        elif phase == "prime_day":
            tasks = self._generate_prime_day_tasks(asin)
        
        for task in tasks:
            self.add_task(task)
        
        return tasks
    
    def _generate_new_product_tasks(self, asin: str) -> List[OpsTask]:
        """生成新品推广任务"""
        return [
            OpsTask(
                id=f"{asin}-listing-001",
                module=TaskModule.LISTING,
                name="关键词调研",
                description="进行关键词调研和竞争分析",
                duration_hours=4,
                priority=1,
                estimated_cost=200
            ),
            OpsTask(
                id=f"{asin}-listing-002",
                module=TaskModule.LISTING,
                name="标题优化",
                description="撰写优化标题，包含核心关键词",
                duration_hours=2,
                dependencies=[f"{asin}-listing-001"],
                priority=1,
                estimated_cost=100
            ),
            OpsTask(
                id=f"{asin}-listing-003",
                module=TaskModule.LISTING,
                name="图片优化",
                description="优化主图和辅图",
                duration_hours=6,
                dependencies=[f"{asin}-listing-001"],
                priority=2,
                estimated_cost=500
            ),
            OpsTask(
                id=f"{asin}-listing-004",
                module=TaskModule.LISTING,
                name="A+内容",
                description="创建A+内容",
                duration_hours=4,
                dependencies=[f"{asin}-listing-003"],
                priority=3,
                estimated_cost=300
            ),
            OpsTask(
                id=f"{asin}-inventory-001",
                module=TaskModule.INVENTORY,
                name="FBA入库计划",
                description="制定FBA入库计划",
                duration_hours=2,
                dependencies=[f"{asin}-listing-002"],
                priority=1,
                estimated_cost=0
            ),
            OpsTask(
                id=f"{asin}-inventory-002",
                module=TaskModule.INVENTORY,
                name="库存关注设置",
                description="设置库存提醒",
                duration_hours=1,
                dependencies=[f"{asin}-inventory-001"],
                priority=2,
                estimated_cost=0
            ),
            OpsTask(
                id=f"{asin}-ads-001",
                module=TaskModule.ADVERTISING,
                name="广告结构设计",
                description="设计广告活动结构",
                duration_hours=3,
                dependencies=[f"{asin}-listing-002"],
                priority=1,
                estimated_cost=0
            ),
            OpsTask(
                id=f"{asin}-ads-002",
                module=TaskModule.ADVERTISING,
                name="自动广告启动",
                description="启动自动广告",
                duration_hours=1,
                dependencies=[f"{asin}-ads-001", f"{asin}-inventory-001"],
                priority=2,
                estimated_cost=1000
            ),
            OpsTask(
                id=f"{asin}-reviews-001",
                module=TaskModule.REVIEWS,
                name="VINE计划申请",
                description="申请VINE计划",
                duration_hours=1,
                dependencies=[f"{asin}-inventory-001"],
                priority=1,
                estimated_cost=200
            ),
            OpsTask(
                id=f"{asin}-reviews-002",
                module=TaskModule.REVIEWS,
                name="评论关注",
                description="设置评论关注",
                duration_hours=1,
                dependencies=[f"{asin}-reviews-001"],
                priority=2,
                estimated_cost=0
            ),
            OpsTask(
                id=f"{asin}-rufus-001",
                module=TaskModule.RUFUS,
                name="Rufus优化",
                description="优化Rufus问答内容",
                duration_hours=3,
                dependencies=[f"{asin}-reviews-001"],
                priority=2,
                estimated_cost=0
            )
        ]
    
    def _generate_regular_ops_tasks(self, asin: str) -> List[OpsTask]:
        """生成日常运营任务"""
        return [
            OpsTask(
                id=f"{asin}-listing-weekly",
                module=TaskModule.LISTING,
                name="周度Listing检查",
                description="检查Listing表现",
                duration_hours=1,
                priority=2,
                estimated_cost=50
            ),
            OpsTask(
                id=f"{asin}-ads-daily",
                module=TaskModule.ADVERTISING,
                name="日度广告优化",
                description="广告数据分析与优化",
                duration_hours=2,
                priority=1,
                estimated_cost=0
            ),
            OpsTask(
                id=f"{asin}-inventory-weekly",
                module=TaskModule.INVENTORY,
                name="周度库存盘点",
                description="库存盘点与补货计划",
                duration_hours=1,
                priority=1,
                estimated_cost=0
            ),
            OpsTask(
                id=f"{asin}-reviews-weekly",
                module=TaskModule.REVIEWS,
                name="周度评价分析",
                description="分析评价变化",
                duration_hours=1,
                priority=2,
                estimated_cost=0
            )
        ]
    
    def _generate_prime_day_tasks(self, asin: str) -> List[OpsTask]:
        """生成Prime Day任务"""
        return [
            OpsTask(
                id=f"{asin}-pd-inventory",
                module=TaskModule.INVENTORY,
                name="Prime Day备货",
                description="Prime Day备货计划",
                duration_hours=4,
                priority=1,
                estimated_cost=5000
            ),
            OpsTask(
                id=f"{asin}-pd-ads-prep",
                module=TaskModule.ADVERTISING,
                name="广告预热",
                description="Prime Day前广告预热",
                duration_hours=8,
                priority=1,
                estimated_cost=3000
            ),
            OpsTask(
                id=f"{asin}-pd-ads-live",
                module=TaskModule.ADVERTISING,
                name="活动期间广告调整",
                description="实时调整广告出价",
                duration_hours=12,
                priority=1,
                estimated_cost=5000
            ),
            OpsTask(
                id=f"{asin}-pd-reviews",
                module=TaskModule.REVIEWS,
                name="活动后评价跟进",
                description="活动后评价管理",
                duration_hours=4,
                dependencies=[f"{asin}-pd-ads-live"],
                priority=2,
                estimated_cost=0
            )
        ]
    
    def analyze_dependencies(self) -> Dict[str, Any]:
        """
        分析任务依赖关系
        
        Returns:
            依赖分析结果
        """
        # 构建依赖图
        graph = {}
        
        for task_id, task in self.tasks.items():
            graph[task_id] = DependencyNode(
                task_id=task_id,
                task_name=task.name,
                module=task.module.value,
                incoming=[dep for dep in task.dependencies if dep in self.tasks],
                outgoing=[]
            )
        
        # 构建反向依赖
        for task_id, node in graph.items():
            for dep in node.incoming:
                if dep in graph:
                    graph[dep].outgoing.append(task_id)
        
        # 计算层级
        self._calculate_levels(graph)
        
        self.dependency_graph = graph
        
        # 分析结果
        result = {
            "total_tasks": len(self.tasks),
            "modules": {},
            "parallel_groups": [],
            "bottlenecks": []
        }
        
        # 按模块统计
        module_counts = defaultdict(int)
        for task in self.tasks.values():
            module_counts[task.module.value] += 1
        result["modules"] = dict(module_counts)
        
        # 找出可并行的任务组
        parallel_groups = self._find_parallel_groups(graph)
        result["parallel_groups"] = [
            {"group_id": i, "tasks": g}
            for i, g in enumerate(parallel_groups, 1)
        ]
        
        # 找出瓶颈任务
        bottlenecks = self._find_bottlenecks(graph)
        result["bottlenecks"] = [
            {
                "task_id": b["task_id"],
                "task_name": b["task_name"],
                "reason": b["reason"]
            }
            for b in bottlenecks
        ]
        
        return result
    
    def _calculate_levels(self, graph: Dict[str, DependencyNode]) -> None:
        """计算任务层级"""
        # 找到入度为0的节点（起始节点）
        visited = set()
        levels = {}
        
        def dfs(node_id: str, level: int):
            if node_id in visited:
                return
            visited.add(node_id)
            levels[node_id] = max(levels.get(node_id, 0), level)
            
            if node_id in graph:
                for next_id in graph[node_id].outgoing:
                    dfs(next_id, level + 1)
        
        for node_id in graph:
            if not graph[node_id].incoming:
                dfs(node_id, 0)
        
        for node_id, level in levels.items():
            if node_id in graph:
                graph[node_id].level = level
    
    def _find_parallel_groups(self, graph: Dict[str, DependencyNode]) -> List[List[str]]:
        """找出可并行执行的任务组"""
        if not graph:
            return []
        
        # 按层级分组
        level_groups = defaultdict(list)
        for node_id, node in graph.items():
            level_groups[node.level].append(node_id)
        
        # 每层内的任务可以并行
        return [sorted(group) for group in level_groups.values() if group]
    
    def _find_bottlenecks(self, graph: Dict[str, DependencyNode]) -> List[Dict]:
        """找出瓶颈任务"""
        bottlenecks = []
        
        for node_id, node in graph.items():
            # 出度大于2意味着是重要分发点
            if len(node.outgoing) >= 3:
                bottlenecks.append({
                    "task_id": node_id,
                    "task_name": node.task_name,
                    "reason": f"影响{len(node.outgoing)}个后续任务"
                })
            
            # 链路过长的最后一个节点
            if not node.outgoing and len(graph) > 5:
                # 检查是否在关键路径上
                pass
        
        return bottlenecks[:5]
    
    def calculate_critical_path(self) -> List[str]:
        """
        计算关键路径
        
        Returns:
            关键路径任务ID列表
        """
        if not self.tasks:
            return []
        
        # 构建DAG
        dag = defaultdict(list)
        in_degree = defaultdict(int)
        
        for task_id, task in self.tasks.items():
            for dep in task.dependencies:
                dag[dep].append(task_id)
                in_degree[task_id] += 1
        
        # 拓扑排序并计算最长路径
        dist = {task_id: 0.0 for task_id in self.tasks}
        parent = {task_id: None for task_id in self.tasks}
        
        # Kahn算法变体
        queue = deque([tid for tid in self.tasks if in_degree[tid] == 0])
        
        while queue:
            curr = queue.popleft()
            
            for next_id in dag[curr]:
                task_duration = self.tasks[next_id].duration_hours
                if dist[curr] + task_duration > dist[next_id]:
                    dist[next_id] = dist[curr] + task_duration
                    parent[next_id] = curr
                
                in_degree[next_id] -= 1
                if in_degree[next_id] == 0:
                    queue.append(next_id)
        
        # 找到最长路径终点
        end_node = max(dist, key=dist.get)
        
        # 回溯关键路径
        critical_path = []
        curr = end_node
        while curr is not None:
            critical_path.insert(0, curr)
            curr = parent[curr]
        
        return critical_path
    
    def orchestrate(self, task_ids: List[str] = None) -> ScheduleResult:
        """
        编排任务执行顺序
        
        Args:
            task_ids: 指定任务ID列表，None则编排全部
        
        Returns:
            排程结果
        """
        if task_ids is None:
            task_ids = list(self.tasks.keys())
        
        # 分析依赖
        dep_result = self.analyze_dependencies()
        critical_path = self.calculate_critical_path()
        
        # 构建排程
        schedule = []
        current_time = 0
        
        # 按层级组织
        level_groups = defaultdict(list)
        for task_id in task_ids:
            if task_id in self.dependency_graph:
                level = self.dependency_graph[task_id].level
                level_groups[level].append(task_id)
        
        # 生成排程
        for level in sorted(level_groups.keys()):
            tasks_in_level = level_groups[level]
            
            # 计算该批次开始时间
            if level == 0:
                start_time = 0
            else:
                # 取所有前置任务的完成时间
                max_end = 0
                for task_id in tasks_in_level:
                    task = self.tasks[task_id]
                    for dep_id in task.dependencies:
                        if dep_id in self.tasks:
                            dep_task = self.tasks[dep_id]
                            # 假设前置任务在之前的某批次完成
                            pass
                start_time = max_end
            
            for task_id in sorted(tasks_in_level, key=lambda x: self.tasks[x].priority):
                task = self.tasks[task_id]
                is_critical = task_id in critical_path
                
                schedule.append({
                    "task_id": task_id,
                    "task_name": task.name,
                    "module": task.module.value,
                    "start_hour": start_time,
                    "end_hour": start_time + task.duration_hours,
                    "duration_hours": task.duration_hours,
                    "priority": task.priority,
                    "is_critical": is_critical,
                    "parallel_with": [t for t in tasks_in_level if t != task_id]
                })
        
        # 计算总工期
        total_duration = max((s["end_hour"] for s in schedule), default=0)
        
        # 批次信息
        parallel_batches = [
            {"batch": i+1, "tasks": g}
            for i, g in enumerate(self._find_parallel_groups(self.dependency_graph))
        ]
        
        self.current_schedule = ScheduleResult(
            total_duration=total_duration,
            schedule=schedule,
            critical_path=critical_path,
            parallel_batches=parallel_batches
        )
        
        return self.current_schedule
    
    def get_module_summary(self) -> Dict[str, Any]:
        """获取模块汇总"""
        summary = {}
        
        for module in TaskModule:
            module_tasks = [t for t in self.tasks.values() if t.module == module]
            
            if module_tasks:
                summary[module.value] = {
                    "task_count": len(module_tasks),
                    "total_hours": sum(t.duration_hours for t in module_tasks),
                    "total_cost": sum(t.estimated_cost for t in module_tasks),
                    "priority_tasks": [
                        {"id": t.id, "name": t.name, "priority": t.priority}
                        for t in sorted(module_tasks, key=lambda x: x.priority)[:3]
                    ]
                }
        
        return summary


def main():
    """主函数"""
    if len(sys.argv) < 2:
        print("用法: python ops-orchestrator.py <command> [args]")
        print("命令:")
        print("  orchestrate      - 编排任务")
        print("  dependencies    - 分析依赖关系")
        print("  critical-path   - 计算关键路径")
        return
    
    command = sys.argv[1]
    orchestrator = AmazonOpsOrchestrator()
    
    # 添加示例任务
    asin = "B08N5WRWNW"
    tasks = orchestrator.add_tasks_from_template(asin, "new")
    
    print(f"已添加 {len(tasks)} 个任务\n")
    
    if command == "orchestrate":
        result = orchestrator.orchestrate()
        
        print("=" * 70)
        print("任务编排结果")
        print("=" * 70)
        print(f"\n总工期: {result.total_duration} 小时 ({result.total_duration/8:.1f} 工作日)")
        
        print(f"\n【关键路径】")
        for task_id in result.critical_path:
            task = orchestrator.tasks.get(task_id)
            if task:
                print(f"  → {task.name}")
        
        print(f"\n【执行排程】")
        for s in result.schedule[:10]:  # 只显示前10个
            critical_mark = "🔥" if s["is_critical"] else "  "
            print(f"{critical_mark} {s['start_hour']:.0f}h-{s['end_hour']:.0f}h | {s['module']:12} | {s['task_name']}")
        
        if len(result.schedule) > 10:
            print(f"  ... 还有 {len(result.schedule)-10} 个任务")
        
        print(f"\n【并行批次】")
        for batch in result.parallel_batches[:5]:
            print(f"  批次{batch['batch']}: {', '.join(batch['tasks'][:3])}...")
    
    elif command == "dependencies":
        result = orchestrator.analyze_dependencies()
        
        print("=" * 70)
        print("依赖关系分析")
        print("=" * 70)
        
        print(f"\n【任务统计】")
        print(f"  总任务数: {result['total_tasks']}")
        
        print(f"\n【各模块任务数】")
        for module, count in result['modules'].items():
            print(f"  {module}: {count}个")
        
        print(f"\n【可并行任务组】")
        for group in result['parallel_groups'][:5]:
            print(f"  组{group['group_id']}: {', '.join(group['tasks'][:4])}")
        
        print(f"\n【瓶颈任务】")
        for bn in result['bottlenecks']:
            print(f"  ⚠ {bn['task_name']} - {bn['reason']}")
    
    elif command == "critical-path":
        critical_path = orchestrator.calculate_critical_path()
        
        print("=" * 70)
        print("关键路径分析")
        print("=" * 70)
        
        print(f"\n关键路径 ({len(critical_path)} 个任务):")
        
        total_hours = 0
        for i, task_id in enumerate(critical_path, 1):
            task = orchestrator.tasks.get(task_id)
            if task:
                total_hours += task.duration_hours
                print(f"  {i}. {task.name}")
                print(f"     模块: {task.module.value} | 时长: {task.duration_hours}h | 优先级: {task.priority}")
        
        print(f"\n关键路径总时长: {total_hours}h ({total_hours/8:.1f} 工作日)")
    
    else:
        print(f"未知命令: {command}")


if __name__ == "__main__":
    main()


Security scan verdicts — ClawScan: suspicious | static analysis: clean | VirusTotal:  | SkillSpector:  ()