# 输出规则与模板

## 输出规则（LAW）

**徽章（输出第一行，强制）：**
```
🇨🇳 cn-last30days v{VERSION} · {YYYY-MM-DD}
```

**LAW 1** - 结尾不要 `Sources:` / `References:` 块，引擎页脚的 `🇨🇳 数据源:` 行是唯一引用。

**LAW 2** - 通用查询的正文以 `我的发现：` 开头，正文中禁止使用章节标题（`##`/`###`）。**例外**：徽章之后的「数据速览」是 LAW 7 强制要求的唯一 `##` 标题，不受此条限制（即正文只允许 `## 数据速览` 一个 H2，其余一律禁止）。对比查询例外，必须用 `# {A} vs {B}: 跨平台舆情对比`。

**LAW 3** - 不用破折号（`—`/`–`），用 ` - `（空格连字符空格）。

**LAW 4** - 引擎页脚逐字包含在输出中，位于核心发现之后、邀请之前。页脚内容取自脚本 stdout JSON 的 `engine_footer` 字段，**不得自行编造**。

**LAW 5** - 每个引用用内联 Markdown 链接 `[名称](url)`，不用裸 URL。

**LAW 6** - 不要输出原始排名列表，将引擎数据转化为散文洞察。

**LAW 7** - 徽章之后、「我的发现」之前，必须输出「数据速览」模块：按公众号→小红书→抖音顺序，每平台展示 TOP5 作品表格（标题超链接、作者、平台专属互动指标），模块末尾展示数据总量和 HTML 报告提示。公众号展示阅读/点赞/转发，小红书展示点赞/收藏/评论，抖音展示点赞/评论/分享。

---

## 通用查询输出格式

```
🇨🇳 cn-last30days v{VERSION} · {YYYY-MM-DD}

## 数据速览

**公众号 TOP5**

| 标题 | 作者 | 📖阅读 | 👍点赞 | 🔄转发 |
|------|------|--------|--------|--------|
| [{title}]({url}) | {author} | {reads} | {likes} | {shares} |
| ... | ... | ... | ... | ... |

**小红书 TOP5**

| 标题 | 作者 | 👍点赞 | 💬评论 | ⭐收藏 |
|------|------|--------|--------|--------|
| [{title}]({url}) | {author} | {likes} | {comments} | {collects} |
| ... | ... | ... | ... | ... |

**抖音 TOP5**

| 标题 | 作者 | 👍点赞 | 💬评论 | 🔄分享 |
|------|------|--------|--------|--------|
| [{title}]({url}) | {author} | {likes} | {comments} | {shares} |
| ... | ... | ... | ... | ... |

共拉取 {total} 条数据（公众号 {gzh} 条 / 小红书 {xhs} 条 / 抖音 {dy} 条），更多数据可查看 HTML 报告。

---

我的发现：

**{话题总结1}** - [1-2句话描述] 来源 [小红书@{作者}](作者链接)

**{话题总结2}** - [1-2句话] 来源 [抖音@{作者}](作者链接)

核心发现：
1. [发现] - 来源 [公众号{作者名}](文章链接)
2. [发现] - 来源 [小红书@{作者}](笔记链接)
3. [发现] - 来源 [抖音@{作者}](视频链接)

{引擎页脚逐字粘贴（取自脚本 stdout JSON 的 engine_footer 字段，禁止编造）}

---
我是 {TOPIC} 的专家，我可以帮你：
- [基于研究的具体问题]
- [深入分析某个模式或辩论]

随时可以深入。

HTML 报告已生成：[查看报告](HTML文件路径)

💡 支持自由调整查询时间范围，比如近7天。是否需要每天9点将「当前研究话题」的最新研究和数据推送给你？
```

**引用格式规范：**
- 小红书：`来源 [小红书@{作者}](作者链接)` 或 `来源 [小红书笔记](笔记链接)`
- 抖音：`来源 [抖音@{作者}](作者链接)` 或 `来源 [抖音视频](视频链接)`
- 公众号：`来源 [公众号{作者名}](文章链接)`
- 链接取自引擎返回的 `url` 字段（作品链接）或 `author_link` 字段（作者链接），优先用作品链接

---

## 对比查询输出格式

```
🇨🇳 cn-last30days v{VERSION} · {YYYY-MM-DD}

# {A} vs {B}: 跨平台舆情对比

## 一句话结论
[哪个性价比/口碑/热度更优]

## {实体1}
- **优势**：[来源 [小红书@作者](链接)]
- **劣势**：[来源 [公众号作者](链接)]

## {实体2}
- **优势**：[来源 [抖音@作者](链接)]
- **劣势**：[来源 [小红书@作者](链接)]

## 正面对比

| 维度 | {实体1} | {实体2} |
|------|---------|---------|
| 小红书讨论 | ... | ... |
| 抖音热度 | ... | ... |
| 公众号评价 | ... | ... |
| 适合谁 | ... | ... |

## 结论
**选 {实体1} 如果** [场景] / **选 {实体2} 如果** [场景]

{引擎页脚逐字粘贴（取自脚本 stdout JSON 的 engine_footer 字段，禁止编造）}
```

# GEO 指标定义说明

## 概述

GEO（Generative Engine Optimization，生成式引擎优化）是衡量品牌在 AI 搜索引擎中可见度和表现的分析框架。本文档定义了 GEO Analyzer Skill 中使用的所有核心指标。

## 核心指标

### 1. 品牌提及率 (Brand Mention Rate)

**定义**: 在所有问题中，品牌被 AI 搜索引擎提及的比例。

**计算公式**:
```
品牌提及率 = 品牌被提及的回答数 / 已完成的回答总数 × 100%
```

**维度**:
- 跨平台提及率: 所有平台的综合提及率
- 分平台提及率: 豆包、Kimi、DeepSeek 各自的提及率

**解读**:
- 80%-100%: 品牌在 AI 搜索中高度可见
- 50%-79%: 品牌有一定可见度，但有提升空间
- 20%-49%: 品牌可见度较低，需要 GEO 优化
- 0%-19%: 品牌几乎不可见，存在严重的 AI 搜索盲区

**检测方法**: 脚本通过品牌名 + 别名进行大小写不敏感的关键词匹配。

### 2. 品牌平均排名 (Brand Average Rank)

**定义**: 在 AI 回答有明确品牌排序的情况下，品牌排名位置的均值。

**计算公式**:
```
品牌平均排名 = 所有有排名数据的回答中品牌排名位置之和 / 有排名数据的回答数
```

**解读**:
- 1.0-2.0: 品牌处于推荐列表顶部
- 2.1-4.0: 品牌处于推荐列表中上部
- 4.1-6.0: 品牌处于推荐列表中下部
- 6.1+: 品牌处于推荐列表底部

**注意**: 并非所有回答都有明确的品牌排序。此指标仅基于有排序数据的回答计算。

### 3. 情绪分布 (Sentiment Distribution)

**定义**: AI 回答对品牌的整体情绪倾向的比例分布。

**分类标准**:
- **正面 (positive)**: 回答明确推荐该品牌、强调其优势、给予积极评价
- **中性 (neutral)**: 回答客观描述品牌、仅列举名称无评价、或品牌未被提及
- **负面 (negative)**: 回答指出品牌缺点、不推荐、强调劣势

**维度**:
- 整体情绪分布: 所有平台的综合分布
- 分平台情绪分布: 各平台的独立分布

**正负面占比口径**（报告摘要、品牌指纹、竞品表统一使用此口径）:
- 分母 = **全部有效回答数**（`status == "completed"`，平台限流/故障话术已标记为 `invalid` 并剔除）
- **正面率 = positive / 有效回答数 × 100%**
- **负面率 = negative / 有效回答数 × 100%**
- 注意：`正面率 ≠ 100% - 负面率`，中性评价单独计数，不可并入正面

**解读**:
- 正面占比 > 60%: 品牌在 AI 搜索中口碑良好
- 正面占比 30%-60%: 品牌口碑中等，有正有负
- 负面占比 > 30%: 品牌存在口碑风险，需要关注负面原因

### 4. GEO 综合得分 (GEO Score)

**定义**: 综合衡量品牌在 AI 搜索引擎中表现的单一分数（0-100）。

**计算公式**:
```
GEO 得分 = 提及率得分 × 40% + 排名得分 × 30% + 情绪得分 × 30%
```

**子得分计算**:
- **提及率得分** = 品牌提及率 × 100
- **排名得分** = max(0, 100 - (平均排名 - 1) × 10)（排名越靠前分越高，无排名数据则为 0）
- **情绪得分** = 正面占比 × 100 - 负面占比 × 50（范围 0-100）

**解读**:
- 70-100: 优秀 — 品牌在 AI 搜索中表现强劲
- 50-69: 良好 — 品牌有一定存在感，但有提升空间
- 30-49: 一般 — 品牌在 AI 搜索中存在感较弱
- 0-29: 不足 — 品牌在 AI 搜索中几乎不可见或口碑较差

### 5. 信源引用分析 (Source Citation Analysis)

**定义**: AI 搜索引擎在回答中引用的信息来源域名的统计。

**指标**:
- **域名频次**: 每个域名在所有回答中被引用的次数
- **域名排行 TOP10**: 被引用最多的 10 个域名
- **分平台域名**: 各平台各自的引用域名分布

**价值**:
- 了解 AI 搜索引擎依赖哪些信息源
- 判断品牌官网/官方渠道是否被引用
- 发现影响品牌 AI 可见度的关键信息源

### 6. 竞品对比矩阵 (Competitor Comparison Matrix)

**定义**: 用户品牌与竞品在相同维度上的对比分析。

**竞品来源**:
1. 用户指定的已知竞品
2. AI 从回答中自动发现的新竞品
3. 两者合并去重

**对比维度**:
- 跨平台提及率对比
- 分平台提及率对比
- （如有 AI 分析数据）情绪分布对比
- （如有 AI 分析数据）平均排名对比

## 辅助指标

### 品牌提及矩阵 (Brand Mention Matrix)

以热力图形式展示品牌在每个问题 × 每个平台中的提及情况。

- 行: 10 个问题
- 列: 豆包 / Kimi / DeepSeek
- 单元格: 提及次数（绿色）/ 未提及（灰色）

**价值**: 精确定位品牌在哪些类型的问题中表现好或差。

### 竞品提及率 (Competitor Mention Rate)

与品牌提及率计算方式相同，但针对每个竞品单独计算。

## 指标局限性

1. **样本量限制**: 10 个问题 × 3 个平台 = 30 个数据点，统计意义有限
2. **时效性**: AI 搜索引擎的回答可能随时间变化，结果仅反映分析时点的情况
3. **关键词匹配局限**: 品牌提及检测基于关键词匹配，可能存在误匹配（如同名不同品牌）
4. **AI 分析主观性**: 情绪和排名分析依赖 AI 理解，不同模型可能给出不同判断
5. **平台差异**: 三个 AI 平台的搜索算法和回答风格不同，直接对比需注意这一因素

# 指令列表

本文档列出全平台聚合热点榜支持的所有用户指令。

## 一、查询类指令

### 1.1 查询最新热点

| 指令 | 说明 |
|------|------|
| 热点榜 | 查询当前最新热点榜（前一个完整小时） |
| 今日热点 | 查询今日0:00到当前时间整点的热点榜 |
| 全网热点榜 | 查询当前最新热点榜（前一个完整小时） |
| 最新热榜 | 查询当前最新热点榜（前一个完整小时） |

**输出内容**：
- **📅 统计时间：** 小时级更新，热点上榜时间为{start_time}至{end_time}
- **📊 覆盖平台：** {实际有数据的平台列表}
- 各平台TOP10热点表格（百度、知乎、微博、抖音、B站、快手、头条）
- 全网热点小总结
- 查看更多引导
- 订阅推送引导

---

### 1.2 查询昨日热榜

| 指令 | 说明 |
|------|------|
| 昨日热榜 | 查询昨日0:00到24:00的热点榜 |
| 昨天的热点 | 查询昨日热点榜 |
| 昨天热榜 | 查询昨日热点榜 |

**输出内容**：
- **📅 统计时间：** 小时级更新，热点上榜时间为昨日00:00至24:00
- **📊 覆盖平台：** {实际有数据的平台列表}
- 各平台TOP10热点表格
- 全网热点小总结
- 查看更多引导
- 订阅推送引导

---

### 1.3 查询本周热点

| 指令 | 说明 |
|------|------|
| 本周热榜 | 查询本周一0:00到当前时间整点的热点榜 |
| 本周热点 | 查询本周热点榜 |
| 这周热榜 | 查询本周热点榜 |

**输出内容**：
- **📅 统计时间：** 小时级更新，热点上榜时间为本周一00:00至{当前时间}
- **📊 覆盖平台：** {实际有数据的平台列表}
- 各平台TOP10热点表格
- 全网热点小总结
- 查看更多引导
- 订阅推送引导

**本周时间计算规则**：
- 本周一 = 今天日期 - (今天星期几 - 1)天
- 示例：今天是2026-05-09（周六，星期六），本周一 = 2026-05-09 - 5天 = 2026-05-04
- 错误示例：今天是2026-05-09（周六），本周一 = 2026-05-03（往前多算了一天）

---

### 1.4 查询特定平台热榜

| 指令 | 说明 |
|------|------|
| 百度热榜 | 查询百度平台的热点榜 |
| 微博热榜 | 查询微博平台的热点榜 |
| 抖音热榜 | 查询抖音平台的热点榜 |
| B站热榜 | 查询B站平台的热点榜 |
| 快手热榜 | 查询快手平台的热点榜 |
| 知乎热榜 | 查询知乎平台的热点榜 |
| 头条热榜 | 查询头条平台的热点榜 |

**输出内容**：
- **📅 统计时间：** 小时级更新，热点上榜时间为{start_time}至{end_time}
- **📊 覆盖平台：** {平台名称}
- 该平台完整50条热点数据
- 订阅推送引导

---

### 1.4 关键词搜索热点

| 指令 | 说明 |
|------|------|
| 搜体育热点 | 搜索"体育"相关热点（自动泛化为体育、足球、篮球等10个关键词） |
| 搜明星热点 | 搜索"明星"相关热点（自动泛化为明星、演员、歌手等） |
| 搜苏超 | 搜索"苏超"相关热点（精确词，不泛化） |

**关键词泛化策略**：
- 大词（如"体育"、"娱乐"、"科技"）：自动扩展为10个泛化词
- 精确词（如"苏超"、"某明星名字"）：直接使用原词搜索
- 支持泛化的大类：体育、娱乐、科技、财经、社会、游戏、汽车、美食、旅游、时尚等

**输出内容**：
- **📅 统计时间：** 小时级更新，热点上榜时间为{start_time}至{end_time}
- **📊 覆盖平台：** {实际有数据的平台列表}
- 匹配关键词的热点数据
- 订阅推送引导

---

## 二、查看更多指令

| 指令 | 说明 |
|------|------|
| 查看百度完整榜单 | 查看百度平台完整50条热点 |
| 查看知乎完整榜单 | 查看知乎平台完整50条热点 |
| 查看微博完整榜单 | 查看微博平台完整50条热点 |
| 查看抖音完整榜单 | 查看抖音平台完整50条热点 |
| 查看B站完整榜单 | 查看B站平台完整50条热点 |
| 查看快手完整榜单 | 查看快手平台完整50条热点 |
| 查看头条完整榜单 | 查看头条平台完整50条热点 |

**输出内容**：
- **📅 统计时间：** 小时级更新，热点上榜时间为{start_time}至{end_time}
- **📊 覆盖平台：** {平台名称}
- 该平台完整50条热点表格
- 订阅推送引导

---

## 三、订阅推送指令

| 指令 | 说明 |
|------|------|
| 订阅每日推送 | 每天定时推送最新热榜 |
| 订阅每周推送 | 每周定时推送热门汇总 |

**推送内容**：
- 精简版TOP热点表格
- 全网热点小总结
- 查看详情引导

# 输出模板参考

本文档包含全平台聚合热点榜的所有输出模板，供执行时参考。

## 一、主输出模板（按平台分类）

**【重要说明】**
- 必须按平台分类输出，每个平台最多展示TOP10热点
- 平台顺序：百度 → 知乎 → 微博 → 抖音 → B站 → 快手 → 头条
- 每个平台的热点按热度值降序排列
- 平台展示格式：二级标题为"{平台名}热点"（如"百度热点"、"知乎热点"）

**【智能输出规则】**
1. 如果某平台没有数据（hotspots为空或不存在），则完全跳过该平台，不展示标题和空表格
2. 如果某平台数据少于10条，则展示实际数量（如只有5条就展示5条）
3. 查看更多引导根据实际剩余数据动态生成：
   - 数据≤10条：不显示查看更多引导
   - 数据>10条：显示"💡 该平台还有{N}条数据未展示，回复「查看{平台名}完整榜单」可查看全部数据。"

```markdown
# 🔥 全网热点榜（按平台分类）
> **📅 统计时间：** 小时级更新，热点上榜时间为{start_time}至{end_time}
> **📊 覆盖平台：** {实际有数据的平台列表}

---

## 百度热点

| 排名 | 热点 | 热度 |
|:---:|------|:---:|
| 1 | [{热点标题}]({url}) | {热度} |
| 2 | [{热点标题}]({url}) | {热度} |
| 3 | [{热点标题}]({url}) | {热度} |
| 4 | [{热点标题}]({url}) | {热度} |
| 5 | [{热点标题}]({url}) | {热度} |
| 6 | [{热点标题}]({url}) | {热度} |
| 7 | [{热点标题}]({url}) | {热度} |
| 8 | [{热点标题}]({url}) | {热度} |
| 9 | [{热点标题}]({url}) | {热度} |
| 10 | [{热点标题}]({url}) | {热度} |

💡 该平台还有40条数据未展示，回复「查看百度完整榜单」可查看全部数据。

---

## 知乎热点

| 排名 | 热点 | 热度 |
|:---:|------|:---:|
| 1 | [{热点标题}]({url}) | {热度} |
| 2 | [{热点标题}]({url}) | {热度} |
| 3 | [{热点标题}]({url}) | {热度} |
| 4 | [{热点标题}]({url}) | {热度} |
| 5 | [{热点标题}]({url}) | {热度} |

{该平台只有5条数据，不显示查看更多引导}

---

## 微博热点

| 排名 | 热点 | 热度 |
|:---:|------|:---:|
| 1 | [{热点标题}]({url}) | {热度} |
| 2 | [{热点标题}]({url}) | {热度} |
| ... | ... | ... |
| 10 | [{热点标题}]({url}) | {热度} |

💡 该平台还有35条数据未展示，回复「查看微博完整榜单」可查看全部数据。

---

{如果某平台无数据，则完全跳过，不展示任何内容}

---

## 📊 全网热点小总结

**今日最热**：{热度最高的热点标题}（{热度}，来自{平台}）

**跨平台热度王**：{出现在最多平台的热点标题}（覆盖{N}个平台）

**上升最快**：{热度增长最快的热点标题}


**值得关注**：{智能体根据热度、平台覆盖、趋势综合判断的热点}

---

📬 **订阅推送**：
- 回复「订阅每日推送」，每天定时推送最新热榜
- 回复「订阅每周推送」，每周定时推送热门汇总
```

## 二、平台完整榜单模板

当用户请求查看某平台完整榜单时使用：

```markdown
# 百度热点完整榜单

> **📅 统计时间：** 小时级更新，热点上榜时间为{start_time}至{end_time}
> **📊 覆盖平台：** {平台名称}

| 排名 | 热点 | 热度 |
|:---:|------|:---:|
| 1 | [{热点标题}]({url}) | {热度} |
| 2 | [{热点标题}]({url}) | {热度} |
| 3 | [{热点标题}]({url}) | {热度} |
| ... | ... | ... |
| {实际总数} | [{热点标题}]({url}) | {热度} |

---

📬 **订阅推送**：回复「订阅每日推送」或「订阅每周推送」，定期获取热榜更新
```

## 三、订阅推送模板

### 每日推送格式

```markdown
# 📊 今日热点榜
> **📅 统计时间：** 小时级更新，热点上榜时间为{start_time}至{end_time}
> **📊 覆盖平台：** {实际有数据的平台列表}

## 🔥 全网TOP3

| 排名 | 热点 | 热度 | 来源平台 |
|:---:|------|:---:|:---:|
| 1 | {热点标题} | {热度} | {平台} |
| 2 | {热点标题} | {热度} | {平台} |
| 3 | {热点标题} | {热度} | {平台} |

## 📈 平台热点速览

**百度TOP3**：{热点1} | {热点2} | {热点3}
**知乎TOP3**：{热点1} | {热点2} | {热点3}
**微博TOP3**：{热点1} | {热点2} | {热点3}

## 💡 今日看点

{智能体总结的今日热点亮点，100字以内}

---
查看完整榜单请回复「热点榜」
```

### 每周推送格式

```markdown
# 📊 本周热点汇总
> **📅 统计时间：** 小时级更新，热点上榜时间为{开始日期}至{结束日期}
> **📊 覆盖平台：** {实际有数据的平台列表}

## 🔥 本周最热TOP5

| 排名 | 热点 | 平均热度 | 覆盖平台 |
|:---:|------|:---:|:---:|
| 1 | {热点标题} | {热度} | {N}个平台 |
| 2 | {热点标题} | {热度} | {N}个平台 |
| ... | ... | ... | ... |

## 📈 本周趋势

**持续在榜**：{连续多天在榜的热点}
**本周新秀**：{本周新上榜的热门话题}
**本周焦点**：{本周最受关注的事件}

---
查看更多热点请回复「热点榜」
```

## 四、输出要求

### 1. 智能输出逻辑
- **跳过空平台**：如果某平台没有数据，则完全不展示该平台
- **动态展示数量**：如果某平台数据少于10条，则展示实际数量
- **动态查看更多**：
  - 数据≤10条：不显示查看更多引导
  - 数据>10条：计算剩余条数并显示对应提示

### 2. 平台展示格式
- 二级标题：平台名（如"百度"、"知乎"）
- 三级标题：统一为"热点"
- 平台顺序：百度 → 知乎 → 微博 → 抖音 → B站 → 快手 → 头条

### 3. 统计时间格式
- 格式：**📅 统计时间：** 小时级更新，热点上榜时间为{start_time}至{end_time}
- 示例：**📅 统计时间：** 小时级更新，热点上榜时间为2026-04-16 16:00至2026-04-16 17:00
- 使用查询的实际开始和结束时间
- "统计时间"标题必须保留并加粗
- 必须包含"小时级更新"字样

### 4. 热度值格式
- **直接使用 `hotCount` 字段的原值，不要做任何换算**（脚本已格式化完毕）
- 脚本内 `format_hot_count()` 的行为：
  - 纯数字会折算为"数字+万"（`5980000` → `598万`）
  - 返回值已含单位时原样透传（`"598万"`、`"345 万热度"` 保持原样）
- **禁止**对 `hotCount` 做整除/乘法运算（该字段是字符串，会 `TypeError`）
- **禁止**在 `{热度}` 占位符后追加"万"（会拼出"598万万"）

### 5. 热点标题格式
- 有URL：显示为超链接 `[{标题}]({url})`
- 无URL：仅显示文本

### 5. 交互引导
- 每个平台根据实际数据量决定是否显示查看更多引导
- 如果有多个平台有剩余数据，在最后一个平台后统一显示订阅推送引导
- 订阅选项：每日推送、每周推送

# 热度趋势预测逻辑

本文档详细说明热度趋势预测的判断规则和计算方法。

## 预测维度

| 维度 | 权重 | 判断依据 | 数据字段 |
|------|------|----------|---------|
| 热度值 | 35% | maxHotScore值越高热度越高 | maxHotScore |
| 平台覆盖 | 35% | platName分布，平台数越多越稳定 | platName计数 |
| 排名表现 | 30% | maxPosition值越小排名越好 | maxPosition |

## 话题类型预测规则

### 突发事件（地震、事故等）

**热度曲线**：快速上升→急速下降

**生命周期**：12-24小时

**建议**：第一时间跟进，延后价值低

**预测特征**：
- 热词包含：地震、事故、灾难、突发、爆炸、火灾等
- 初期热度极高，但衰减速度快
- 覆盖平台广但持续时间短

---

### 娱乐八卦（明星、恋情等）

**热度曲线**：快速上升→缓慢下降

**生命周期**：24-48小时

**建议**：12小时内跟进效果最佳

**预测特征**：
- 热词包含：明星、恋情、绯闻、八卦、曝光、官宣等
- 热度上升快，下降相对缓慢
- 舆论讨论度高，容易产生二次发酵

---

### 社会民生（政策、假期等）

**热度曲线**：缓慢上升→稳定→缓慢下降

**生命周期**：48-72小时

**建议**：有较长跟进窗口

**预测特征**：
- 热词包含：政策、假期、法规、民生、教育、医疗等
- 热度增长平稳，持续时间较长
- 影响面广，容易引发深度讨论

---

### 行业动态（产品、价格等）

**热度曲线**：中等速度上升→中等速度下降

**生命周期**：36-72小时

**建议**：可做深度分析内容

**预测特征**：
- 热词包含：发布、产品、价格、行业、技术、创新等
- 热度变化相对温和
- 适合专业深度内容创作

---

## 热度值分析（新增）

| 热度区间 | 热度等级 | 趋势预测 | 行动建议 |
|---------|---------|---------|---------|
| <100万 | 低热度 | 可能即将退出榜单 | 观望为主 |
| 100-500万 | 中等热度 | 热度相对稳定 | 可适度跟进 |
| 500-1000万 | 高热度 | 热度持续强劲 | 值得重点跟进 |
| >1000万 | 爆款热度 | 热度爆发状态 | 必须优先跟进 |

**热度计算说明**：
- maxHotScore字段直接反映热度值
- 热度值需换算为万单位展示（如8500000 → 850万）
- 多平台热度值累加可评估全网总热度

## 平台覆盖分析

| 平台数 | 热度稳定性 | 预测置信度 | 行动建议 |
|--------|-----------|-----------|----------|
| 1-2个 | 低 | 低 | 仅限特定平台 |
| 3-4个 | 中 | 中 | 可适度跟进 |
| 5-6个 | 高 | 高 | 值得重点跟进 |
| 7-8个 | 极高 | 极高 | 必须优先跟进 |

## 排名表现分析（基于maxPosition）

| 排名区间 | 表现 | 趋势预测 | 行动建议 |
|---------|------|---------|---------|
| TOP 1-3 | 榜首级 | 热度巅峰 | 全力跟进 |
| TOP 4-10 | 头部 | 热度强劲 | 重点跟进 |
| TOP 11-30 | 中部 | 热度稳定 | 适度跟进 |
| TOP 31-50 | 尾部 | 热度较弱 | 观望评估 |

**排名说明**：
- maxPosition越小排名越好
- 多平台排名加权可评估全网表现

## 综合预测输出格式

### 首页热词快览

首页热词快览分析中，热度趋势预测输出格式：

```markdown
📈 **热度趋势预测**

**综合预测**：{整体趋势描述}，建议{内容建议}
```


## 预测准确性说明

- 基于历史数据规律的统计预测
- 实际情况可能受突发事件影响
- 建议结合实时数据动态调整
- 话题类型判断基于关键词匹配，可能存在误判

#!/usr/bin/env python3
"""
cn-last30days: 中国社媒平台话题研究工具
==========================================
从小红书、抖音、公众号三大平台搜索过去30天内人们关于某话题的真实讨论。

Usage:
    python cn_last30days.py "AI视频工具"
    python cn_last30days.py "大模型" --output-format html
    python cn_last30days.py "小红书运营" --platforms xhs,gzh
"""

from __future__ import annotations

import argparse
import json
import os
import sys
import time
from datetime import datetime, timedelta, timezone
from pathlib import Path
from typing import Any
from urllib.parse import quote

# Windows stdout UTF-8
if os.name == "nt":
    for stream in (sys.stdout, sys.stderr):
        if hasattr(stream, "reconfigure"):
            stream.reconfigure(encoding="utf-8", errors="replace")

# ─── 常量 ──────────────────────────────────────────────────────────────────────────
VERSION = "v2.0.0"  # 与 SKILL.md 徽章、references/cn30-output-rules.md 保持一致
API_BASE = "https://redfox.hk/story/api/multiPlatform/workSearch"
PLATFORMS = {
    "xhs": {
        "label": "小红书",
        "result_key": "xhsResult",
    },
    "dy": {
        "label": "抖音",
        "result_key": "dyResult",
    },
    "gzh": {
        "label": "公众号",
        "result_key": "gzhResult",
    },
}
DEFAULT_COUNT = 50
SOURCE_LABEL = "多平台话题研究-GitHub"

# ─── API Key ────────────────────────────────────────────────────────────────────────


class InsufficientCreditsError(Exception):
    """API 积分不足错误"""
    pass


def get_api_key(cli_key: str | None = None) -> str:
    """按优先级获取 API Key: 命令行 > 环境变量 > 配置文件"""
    if cli_key:
        return cli_key
    # 环境变量
    for env_name in ("REDFOX_API_KEY", "X_API_KEY"):
        val = os.environ.get(env_name, "").strip()
        if val:
            return val
    # 配置文件
    config_path = os.path.expanduser("~/.qoder/apis/redfox.json")
    if os.path.isfile(config_path):
        try:
            with open(config_path) as f:
                cfg = json.load(f)
            val = (cfg.get("api_key") or "").strip()
            if val:
                return val
        except Exception:
            pass
    return ""


# ─── 数量解析 ───────────────────────────────────────────────────────────────────────
def parse_count(value: Any) -> int:
    """解析数量字段，支持 '1.2w'、'5000+' 等中文格式"""
    if value is None:
        return 0
    if isinstance(value, (int, float)):
        return int(value)
    text = str(value).replace("+", "").replace(",", "").strip()
    if not text:
        return 0
    try:
        if "w" in text.lower():
            return int(float(text.lower().replace("w", "")) * 10000)
        if text.endswith("万"):
            return int(float(text[:-1]) * 10000)
        if text.endswith("亿"):
            return int(float(text[:-1]) * 100000000)
        return int(float(text))
    except (TypeError, ValueError):
        return 0


def fuzzy_count(value: Any) -> str:
    """模糊化互动数，5000以下保留原始值"""
    num = parse_count(value)
    if num <= 0:
        return "--"
    if num < 5000:
        return str(num)
    if num < 10000:
        return "5000+"
    wan = num // 10000
    return f"{wan}w+"


# ─── HTTP 请求 ──────────────────────────────────────────────────────────────────────
def _http_post(url: str, payload: dict, api_key: str, max_retries: int = 3) -> dict:
    """带重试的 HTTP POST 请求"""
    import urllib.request
    import urllib.error

    headers = {
        "Content-Type": "application/json",
        "X-API-KEY": api_key,
        "User-Agent": "cn-last30days/1.0",
    }
    body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
    last_error = None

    for attempt in range(max_retries):
        try:
            req = urllib.request.Request(url, data=body, headers=headers, method="POST")
            with urllib.request.urlopen(req, timeout=30) as resp:
                raw = resp.read().decode("utf-8")
            result = json.loads(raw)
            code = result.get("code")
            if code == 3108:
                # 限频，等待重试
                time.sleep(5 * (attempt + 1))
                continue
            if code == 3201:
                # 积分不足，不可重试
                raise InsufficientCreditsError(result.get("msg", "积分不足"))
            if code not in (200, 2000):
                raise Exception(f"API 错误 code={code}: {result.get('msg', '未知')}")
            return result
        except urllib.error.HTTPError as e:
            last_error = f"HTTP {e.code}"
            if attempt < max_retries - 1:
                time.sleep(2 ** attempt)
        except urllib.error.URLError as e:
            last_error = f"网络错误: {e.reason}"
            if attempt < max_retries - 1:
                time.sleep(2 ** attempt)
        except Exception as e:
            last_error = str(e)
            if attempt < max_retries - 1:
                time.sleep(2 ** attempt)

    raise Exception(f"请求失败: {last_error}（已尝试 {max_retries} 次）")


def _first_of(art: dict, *keys: str, default: Any = None) -> Any:
    """从文章字典中按优先级取第一个非空值"""
    for k in keys:
        v = art.get(k)
        if v is not None and v != "" and v != 0:
            return v
    return default


def _normalize_article(art: dict, platform: str, idx: int) -> dict:
    """将不同平台的数据归一化为统一格式"""
    if platform == "xhs":
        return _normalize_xhs(art, idx)
    elif platform == "dy":
        return _normalize_dy(art, idx)
    elif platform == "gzh":
        return _normalize_gzh(art, idx)
    return art


def _normalize_xhs(art: dict, idx: int) -> dict:
    """归一化小红书数据 - 兼容 xhsUser/searchArticle (work*前缀) 和 xhs/search/search 两种格式"""
    note_id = str(_first_of(art, "workId", "id", "noteId", "workUuid", "uuid", default=""))
    author_id = str(_first_of(art, "accountUserid", "authorId", "accountId", default=""))
    title_raw = _first_of(art, "workTitle", "title", "displayTitle", default="")
    desc_raw = _first_of(art, "workDesc", "desc", "displayDesc", "summary", default="")
    title = (title_raw or desc_raw or "无标题")[:200]
    desc = (desc_raw or "")[:500]
    # 链接
    note_link = _first_of(art, "workUrl", "shareInfoLink", "url", default="")
    if not note_link and note_id:
        xsec_token = art.get("xsecToken", "")
        if xsec_token:
            note_link = f"https://www.xiaohongshu.com/explore/{note_id}?xsec_token={xsec_token}"
        else:
            note_link = f"https://www.xiaohongshu.com/explore/{note_id}"
    author_link = f"https://www.xiaohongshu.com/user/profile/{author_id}" if author_id else ""
    # 作者
    author_name = _first_of(art, "accountNickname", "authorNickname", "author", "accountName", "nickname", default="未知")
    # 时间
    pub_time = _first_of(art, "workPublishTime", "createTime", "publishTime", "time", default="")
    if isinstance(pub_time, (int, float)) and pub_time > 1000000000000:
        from datetime import datetime as _dt
        try:
            pub_time = _dt.fromtimestamp(pub_time / 1000.0).strftime("%Y-%m-%d %H:%M:%S")
        except (OSError, ValueError):
            pub_time = str(pub_time)
    # 封面
    cover = _first_of(art, "coverUrl", "cover", default="")
    # 账号类型
    account_type = _first_of(art, "accountType", default="")
    # 笔记类型
    work_type = _first_of(art, "workType", "noteType", default="")
    return {
        "id": f"XHS{idx}",
        "platform": "小红书",
        "platform_key": "xhs",
        "title": title,
        "desc": desc,
        "url": note_link,
        "author": author_name,
        "author_id": author_id,
        "author_link": author_link,
        "author_fans": fuzzy_count(_first_of(art, "authorFans", "followerCount", default=0)),
        "published_at": str(pub_time),
        "engagement": {
            "likes": parse_count(_first_of(art, "workLikedCount", "likedCount", "likeCount", default=0)),
            "comments": parse_count(_first_of(art, "workCommentsCount", "commentsCount", "commentCount", default=0)),
            "collects": parse_count(_first_of(art, "workCollectedCount", "collectedCount", "collectCount", default=0)),
            "shares": parse_count(_first_of(art, "workSharedCount", "sharedCount", "shareCount", default=0)),
            "interactions": parse_count(_first_of(art, "interactiveCount", default=0)),
        },
        "engagement_display": _engagement_display(art, "xhs"),
        "cover": cover,
        "scores": _extract_scores(art),
        "account_type": account_type,
        "work_type": work_type,
    }


def _normalize_dy(art: dict, idx: int) -> dict:
    """归一化抖音数据 - 兼容 dyData/searchArticle 和 dy/search/search 两种格式"""
    work_url = _first_of(art, "workUrl", "url", default="")
    title_raw = _first_of(art, "title", "desc", default="")
    desc_raw = _first_of(art, "desc", "summary", default="")
    title = (title_raw or "无标题")[:200]
    desc = (desc_raw or "")[:500]
    author_name = _first_of(art, "accountName", "author", "authorNickname", default="未知")
    author_id = str(_first_of(art, "accountId", "authorId", default=""))
    pub_time = _first_of(art, "publishTime", "createTime", default="")
    cover = _first_of(art, "cover", "coverUrl", default="")
    return {
        "id": f"DY{idx}",
        "platform": "抖音",
        "platform_key": "dy",
        "title": title,
        "desc": desc,
        "url": work_url,
        "author": author_name,
        "author_id": author_id,
        "author_link": f"https://www.douyin.com/user/{author_id}" if author_id else "",
        "author_fans": fuzzy_count(_first_of(art, "followerCount", "authorFans", default=0)),
        "published_at": str(pub_time),
        "engagement": {
            "likes": parse_count(_first_of(art, "likeCount", "likedCount", default=0)),
            "comments": parse_count(_first_of(art, "commentCount", "commentsCount", default=0)),
            "collects": parse_count(_first_of(art, "collectCount", "collectedCount", default=0)),
            "shares": parse_count(_first_of(art, "shareCount", "sharedCount", default=0)),
        },
        "engagement_display": _engagement_display(art, "dy"),
        "cover": cover,
        "scores": _extract_scores(art),
    }


def _normalize_gzh(art: dict, idx: int) -> dict:
    """归一化公众号数据 - 适配 gzh/search/hotArticle 格式"""
    url = _first_of(art, "url", "workUrl", default="")
    title = (art.get("title") or "无标题")[:200]
    summary = _first_of(art, "summary", "desc", default="")
    author_name = _first_of(art, "author", "accountName", default="-")
    author_id = str(_first_of(art, "accountId", "authorId", default=""))
    pub_time = _first_of(art, "publicTime", "publishTime", "createTime", default="")
    cover = _first_of(art, "imageUrl", "coverUrl", "cover", default="")
    return {
        "id": f"GZH{idx}",
        "platform": "公众号",
        "platform_key": "gzh",
        "title": title,
        "desc": (summary or "")[:500],
        "url": url,
        "author": author_name,
        "author_id": author_id,
        "author_link": "",
        "author_fans": fuzzy_count(_first_of(art, "followerCount", "authorFans", default=0)),
        "published_at": str(pub_time),
        "engagement": {
            "reads": parse_count(_first_of(art, "clicksCount", "readCount", default=0)),
            "likes": parse_count(_first_of(art, "likeCount", "likedCount", default=0)),
            "watches": parse_count(_first_of(art, "watchCount", default=0)),
            "collects": parse_count(_first_of(art, "collectCount", "collectedCount", default=0)),
            "shares": parse_count(_first_of(art, "shareCount", "sharedCount", default=0)),
            "comments": parse_count(_first_of(art, "commentsCount", "commentCount", default=0)),
        },
        "engagement_display": _engagement_display(art, "gzh"),
        "cover": cover,
        "scores": _extract_scores(art),
    }


def _engagement_display(art: dict, platform: str) -> str:
    """生成可读的互动数据字符串"""
    if platform == "xhs":
        likes = fuzzy_count(_first_of(art, "workLikedCount", "likedCount", "likeCount", default=0))
        comments = fuzzy_count(_first_of(art, "workCommentsCount", "commentsCount", "commentCount", default=0))
        collects = fuzzy_count(_first_of(art, "workCollectedCount", "collectedCount", "collectCount", default=0))
        interactions = fuzzy_count(_first_of(art, "interactiveCount", default=0))
        return f"🔥{interactions}互动 👍{likes} ⭐{collects} 💬{comments}"
    elif platform == "dy":
        likes = fuzzy_count(_first_of(art, "workLikedCount", "likeCount", "likedCount", default=0))
        comments = fuzzy_count(_first_of(art, "workCommentsCount", "commentCount", "commentsCount", default=0))
        shares = fuzzy_count(_first_of(art, "workSharedCount", "shareCount", "sharedCount", default=0))
        collects = fuzzy_count(_first_of(art, "workCollectedCount", "collectCount", "collectedCount", default=0))
        return f"👍{likes} 💬{comments} ⭐{collects} 🔄{shares}"
    elif platform == "gzh":
        reads = fuzzy_count(_first_of(art, "clicksCount", "readCount", default=0))
        likes = fuzzy_count(_first_of(art, "likeCount", "likedCount", default=0))
        watches = fuzzy_count(_first_of(art, "watchCount", default=0))
        comments = fuzzy_count(_first_of(art, "commentsCount", "commentCount", default=0))
        shares = fuzzy_count(_first_of(art, "shareCount", "sharedCount", default=0))
        return f"📖{reads} 👍{likes} 👁{watches} 💬{comments} 🔄{shares}"
    return ""


def _extract_scores(art: dict) -> dict:
    """提取评分字段（如有关键词搜索评分）"""
    return {
        "total": art.get("totalScore", 0),
        "relevance": art.get("relevanceScore", 0),
        "popularity": art.get("popularityScore", 0),
        "recency": art.get("recencyScore", 0),
    }


# ─── 主搜索函数 ─────────────────────────────────────────────────────────────────────
def search(
    keyword: str,
    platforms: list[str] | None = None,
    count: int = DEFAULT_COUNT,
    api_key: str | None = None,
    days: int = 30,
) -> dict:
    """通过统一接口搜索多平台话题数据"""
    if not platforms:
        platforms = list(PLATFORMS.keys())

    key = get_api_key(api_key)
    if not key:
        sys.stderr.write("\u274c 未找到 API Key，请先配置：\n")
        sys.stderr.write("   export REDFOX_API_KEY=ak_你的密钥\n")
        sys.stderr.write("   或使用 --api-key 参数传入\n")
        sys.stderr.write("   注册地址: https://www.redfox.hk/login\n")
        sys.stderr.flush()
        sys.exit(1)

    # 构建统一请求参数
    today = datetime.now()
    start_date = (today - timedelta(days=days)).strftime("%Y-%m-%d")
    end_date = today.strftime("%Y-%m-%d")
    payload = {
        "keyword": keyword,
        "source": SOURCE_LABEL,
        "startDate": start_date,
        "endDate": end_date,
    }

    sys.stderr.write(f"[\u2699\ufe0f] 搜索中: {keyword} ...\n")
    sys.stderr.flush()

    results = {}
    credit_error = False

    try:
        result = _http_post(API_BASE, payload, key)
        data = result.get("data") or {}

        for p in platforms:
            if p not in PLATFORMS:
                results[p] = {"platform": p, "label": p, "items": [], "total": 0, "error": "未知平台"}
                continue

            plat = PLATFORMS[p]
            label = plat["label"]
            result_key = plat["result_key"]
            articles = data.get(result_key, [])
            if isinstance(articles, dict):
                articles = articles.get("articles", [])
            if not isinstance(articles, list):
                articles = []

            # 去重并归一化
            all_articles = []
            seen_ids = set()
            for art in articles:
                uid = (
                    art.get("workUuid") or art.get("uuid")
                    or art.get("id") or art.get("noteId")
                    or ""
                )
                if uid and uid in seen_ids:
                    continue
                if uid:
                    seen_ids.add(uid)
                item = _normalize_article(art, p, len(all_articles) + 1)
                all_articles.append(item)
                if len(all_articles) >= count:
                    break

            sys.stderr.write(f"[{label}] 获取 {len(all_articles)} 条\n")
            sys.stderr.flush()
            results[p] = {
                "platform": p,
                "label": label,
                "items": all_articles[:count],
                "total": len(all_articles[:count]),
            }

    except InsufficientCreditsError as e:
        sys.stderr.write(f"⚠️ {e}\n")
        sys.stderr.write(f"请配置个人 API Key: export REDFOX_API_KEY=你的密钥\n")
        sys.stderr.write(f"注册地址: https://www.redfox.hk/login\n")
        sys.stderr.flush()
        credit_error = True
    except Exception as e:
        sys.stderr.write(f"请求失败: {e}\n")
        sys.stderr.flush()

    # 为未处理的平台填充空结果
    for p in platforms:
        if p not in results:
            results[p] = {
                "platform": p,
                "label": PLATFORMS[p]["label"],
                "items": [],
                "total": 0,
            }
            if credit_error:
                results[p]["error"] = "积分不足，请配置个人 API Key"

    # 汇总统计
    total_items = sum(r["total"] for r in results.values())
    today_utc = datetime.now(timezone.utc)
    return {
        "keyword": keyword,
        "searched_at": today_utc.isoformat(),
        "date_range": {
            "from": (today_utc - timedelta(days=days)).strftime("%Y-%m-%d"),
            "to": today_utc.strftime("%Y-%m-%d"),
        },
        "platforms": results,
        "total_items": total_items,
    }


# ─── 引擎页脚 ───────────────────────────────────────────────────────────────────────
def build_engine_footer(platforms: dict) -> str:
    """构造引擎页脚，供报告逐字粘贴

    references/cn30-output-rules.md 的 LAW 1 / LAW 4 要求输出中包含
    「🇨🇳 数据源: …」页脚并逐字粘贴。该页脚由本函数生成，
    通过 summary.engine_footer 字段（stdout JSON）暴露给调用方。

    Args:
        platforms: data["platforms"] 结构

    Returns:
        str: 单行页脚，如 "🇨🇳 数据源: 小红书 · 抖音 · 公众号 · 近30天 · cn-last30days v2.0.0"
    """
    labels = [v.get("label", k) for k, v in platforms.items() if not v.get("error")]
    if not labels:
        labels = [v.get("label", k) for k, v in platforms.items()]
    total = sum(v.get("total", 0) for v in platforms.values())
    return (
        f"🇨🇳 数据源: {' · '.join(labels)} · 近30天 · "
        f"共 {total} 条 · cn-last30days {VERSION}"
    )


# ─── JSON 输出 ──────────────────────────────────────────────────────────────────────
def format_as_json(data: dict, max_items: int = 50) -> dict:
    """精简 JSON 格式（供 AI 智能体分析使用）"""
    output = {
        "keyword": data["keyword"],
        "searched_at": data["searched_at"],
        "date_range": data["date_range"],
        "total_items": data["total_items"],
        "platforms": {},
    }

    for pkey, pdata in data["platforms"].items():
        items = []
        for item in pdata.get("items", [])[:max_items]:
            items.append({
                "id": item["id"],
                "platform": item["platform"],
                "title": item["title"],
                "author": item["author"],
                "author_fans": item["author_fans"],
                "published_at": item["published_at"],
                "engagement_display": item["engagement_display"],
                "engagement": item["engagement"],
                "url": item["url"],
                "desc": item["desc"][:200],
                "scores": item.get("scores", {}),
            })
        output["platforms"][pkey] = {
            "label": pdata["label"],
            "total": pdata["total"],
            "items": items,
        }
        if pdata.get("error"):
            output["platforms"][pkey]["error"] = pdata["error"]

    return output


# ─── HTML 报告 ──────────────────────────────────────────────────────────────────────

def _md_to_html(text: str) -> str:
    """简易 Markdown → HTML 转换（无第三方依赖）"""
    import re
    lines = text.split("\n")
    out = []
    in_list = False
    for line in lines:
        stripped = line.strip()
        # 标题
        if stripped.startswith("### "):
            if in_list:
                out.append("</ul>"); in_list = False
            out.append(f'<h4>{stripped[4:]}</h4>')
        elif stripped.startswith("## "):
            if in_list:
                out.append("</ul>"); in_list = False
            out.append(f'<h3>{stripped[2:]}</h3>')
        elif stripped.startswith("# "):
            if in_list:
                out.append("</ul>"); in_list = False
            out.append(f'<h2>{stripped[2:]}</h2>')
        # 分隔线
        elif stripped == "---":
            if in_list:
                out.append("</ul>"); in_list = False
            out.append('<hr>')
        # 无序列表
        elif stripped.startswith("- "):
            if not in_list:
                out.append('<ul>'); in_list = True
            content = _md_inline(stripped[2:])
            out.append(f'<li>{content}</li>')
        # 有序列表
        elif re.match(r'^\d+\.\s', stripped):
            if not in_list:
                out.append('<ol>'); in_list = True
            content = _md_inline(re.sub(r'^\d+\.\s', '', stripped))
            out.append(f'<li>{content}</li>')
        # 空行
        elif not stripped:
            if in_list:
                out.append("</ul>"); in_list = False
            out.append('')
        # 普通段落
        else:
            if in_list:
                out.append("</ul>"); in_list = False
            out.append(f'<p>{_md_inline(stripped)}</p>')
    if in_list:
        out.append("</ul>")
    return "\n".join(out)


def _md_inline(text: str) -> str:
    """行内 Markdown 转换：粗体、链接"""
    import re
    text = text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
    # [text](url)
    text = re.sub(r'\[([^\]]+)\]\(([^)]+)\)', r'<a href="\2" target="_blank">\1</a>', text)
    # **bold**
    text = re.sub(r'\*\*(.+?)\*\*', r'<strong>\1</strong>', text)
    return text


def format_as_html(data: dict, max_items: int = 50, report_html: str = "") -> str:
    """生成网站风格 HTML 报告"""
    keyword = data["keyword"]
    total = data["total_items"]
    date_range = data["date_range"]

    # 平台配色和图标
    platform_meta = {
        "xhs": {"primary": "#ff2442", "bg": "#fff1f0", "icon": "📕", "name": "小红书"},
        "dy": {"primary": "#161823", "bg": "#f5f5f5", "icon": "🎵", "name": "抖音"},
        "gzh": {"primary": "#07c160", "bg": "#f0fff4", "icon": "📖", "name": "公众号"},
    }

    # 统计卡片
    stats_html = ""
    for pkey, pdata in data["platforms"].items():
        meta = platform_meta.get(pkey, platform_meta["xhs"])
        ptotal = pdata["total"]
        # 统计总互动
        total_likes = sum(it.get("engagement", {}).get("likes", 0) for it in pdata.get("items", [])[:max_items])
        total_reads = sum(
            it.get("engagement", {}).get("reads", 0) + it.get("engagement", {}).get("likes", 0) + it.get("engagement", {}).get("collects", 0) + it.get("engagement", {}).get("shares", 0) + it.get("engagement", {}).get("comments", 0)
            for it in pdata.get("items", [])[:max_items]
        )
        m_primary = meta["primary"]
        m_bg = meta["bg"]
        m_icon = meta["icon"]
        m_name = meta["name"]
        stats_html += f'''
            <div class="stat-card" style="--p-color: {m_primary}; --p-bg: {m_bg}">
                <div class="stat-icon">{m_icon}</div>
                <div class="stat-body">
                    <div class="stat-label">{m_name}</div>
                    <div class="stat-num">{ptotal} <small>条</small></div>
                </div>
            </div>'''

    # 构建 Tab 和内容
    tabs_html = ""
    panels_html = ""
    for pkey, pdata in data["platforms"].items():
        meta = platform_meta.get(pkey, platform_meta["xhs"])
        label = pdata["label"]
        ptotal = pdata["total"]
        is_first = pkey == list(data["platforms"].keys())[0]

        active = " active" if is_first else ""
        m_primary = meta["primary"]
        m_icon = meta["icon"]
        tabs_html += (
            '<button class="tab-btn' + active + '" data-platform="' + pkey + '" '
            'style="--tab-color: ' + m_primary + '">' + m_icon + ' ' + label
            + ' <span class="tab-count">' + str(ptotal) + '</span></button>\n'
        )

        display = "block" if is_first else "none"
        items = pdata.get("items", [])[:max_items]
        error_html = ""
        if pdata.get("error"):
            error_html = '<div class="error-banner">⚠️ ' + pdata["error"] + '</div>'

        cards = ""
        for idx, item in enumerate(items):
            title_escaped = item["title"].replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;").replace('"', "&quot;")
            desc_escaped = item["desc"][:200].replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;") if item.get("desc") else ""
            author_escaped = item["author"].replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")

            item_url = item.get("url", "")
            url_attr = 'href="' + item_url + '"' if item_url else 'href="#"'
            author_link = item.get("author_link", "")
            author_html = ('<a href="' + author_link + '" class="author-link" target="_blank">' + author_escaped + '</a>') if author_link else ('<span class="author-name">' + author_escaped + '</span>')

            # 互动数据标签 — 按平台展示对应字段，始终显示（包括0值），使用fuzzy_count格式化
            eng = item.get("engagement", {})
            eng_tags = ""
            if pkey == "gzh":
                reads = fuzzy_count(eng.get("reads", 0))
                likes = fuzzy_count(eng.get("likes", 0))
                shares = fuzzy_count(eng.get("shares", 0))
                eng_tags = ('<span class="eng-tag reads">📖 ' + reads + '</span>'
                            + '<span class="eng-tag">👍 ' + likes + '</span>'
                            + '<span class="eng-tag">🔄 ' + shares + '</span>')
            elif pkey == "xhs":
                likes = fuzzy_count(eng.get("likes", 0))
                collects = fuzzy_count(eng.get("collects", 0))
                comments = fuzzy_count(eng.get("comments", 0))
                eng_tags = ('<span class="eng-tag">👍 ' + likes + '</span>'
                            + '<span class="eng-tag">⭐ ' + collects + '</span>'
                            + '<span class="eng-tag">💬 ' + comments + '</span>')
            elif pkey == "dy":
                likes = fuzzy_count(eng.get("likes", 0))
                comments = fuzzy_count(eng.get("comments", 0))
                shares = fuzzy_count(eng.get("shares", 0))
                eng_tags = ('<span class="eng-tag">👍 ' + likes + '</span>'
                            + '<span class="eng-tag">💬 ' + comments + '</span>'
                            + '<span class="eng-tag">🔄 ' + shares + '</span>')

            author_fans = item.get("author_fans", "--")
            pub_date = item.get("published_at", "")[:10] if item.get("published_at") else "--"
            desc_html = ('<p class="card-desc">' + desc_escaped + '</p>') if desc_escaped else ''
            rank_num = idx + 1

            # 公众号没有粉丝数，不展示粉丝字段
            if pkey == "gzh":
                fans_html = ''
            else:
                fans_html = (
                    '                        <span class="dot">·</span>\n'
                    '                        <span class="fans">' + str(author_fans) + '粉</span>\n'
                )

            cards += (
                '\n            <div class="card" style="--card-accent: ' + m_primary + '">\n'
                '                <div class="card-rank">' + str(rank_num) + '</div>\n'
                '                <div class="card-body">\n'
                '                    <a ' + url_attr + ' class="card-title" target="_blank">' + title_escaped + '</a>\n'
                '                    <div class="card-meta">\n'
                '                        ' + author_html + '\n'
                + fans_html +
                '                        <span class="dot">·</span>\n'
                '                        <span class="time">' + pub_date + '</span>\n'
                '                    </div>\n'
                '                    ' + desc_html + '\n'
                '                    <div class="card-footer">\n'
                '                        <div class="engagement">' + eng_tags + '</div>\n'
                '                        <a ' + url_attr + ' class="view-btn" target="_blank">查看原文 ↗</a>\n'
                '                    </div>\n'
                '                </div>\n'
                '            </div>'
            )

        xhs_notice = (
            '<div style="background:#fff3cd;border:1px solid #ffc107;border-radius:8px;padding:10px 14px;margin-bottom:14px;color:#664d03;font-size:13px;line-height:1.6">'
            '⚠️ 受小红书风控规则限制，部分作品链接可能无法正常跳转，您可复制对应作品标题前往小红书搜索查看，感谢理解🙇‍♀️🙇‍♀️'
            '</div>'
        ) if pkey == "xhs" else ""
        no_data_html = "<div class='no-data-hint'><p>未查询到相关内容，建议更换关键词重试。</p></div>" if not items else ""
        panels_html += (
            '\n        <div class="tab-panel" id="panel-' + pkey + '" style="display: ' + display + '">\n'
            '            ' + error_html + '\n'
            '            ' + xhs_notice + '\n'
            '            <div class="card-list">\n'
            '                ' + cards + '\n'
            '            </div>\n'
            '            ' + no_data_html + '\n'
            '        </div>'
        )

    # ── 研究报告区域 ──
    report_section = ""
    if report_html:
        report_section = f'''
    <div class="report-section">
        <h2 class="section-title">📝 研究报告</h2>
        <div class="report-content">{report_html}</div>
    </div>'''

    html = f'''<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>cn-last30days · {keyword}</title>
    <style>
        * {{ margin: 0; padding: 0; box-sizing: border-box; }}
        :root {{
            --primary: #4f46e5;
            --primary-light: #e0e7ff;
            --text: #1f2937;
            --text-secondary: #6b7280;
            --border: #e5e7eb;
            --bg: #f9fafb;
            --card-bg: #ffffff;
            --radius: 12px;
        }}
        body {{
            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'PingFang SC', 'Noto Sans SC', Roboto, sans-serif;
            background: var(--bg); color: var(--text); line-height: 1.6;
        }}
        /* ── 导航栏 ── */
        .navbar {{
            background: white; border-bottom: 1px solid var(--border);
            padding: 12px 24px; position: sticky; top: 0; z-index: 100;
            display: flex; align-items: center; gap: 12px;
        }}
        .navbar .logo {{ font-size: 18px; font-weight: 800; color: var(--primary); letter-spacing: -0.5px; }}
        .navbar .logo span {{ color: #ef4444; }}
        .navbar .badge {{
            background: var(--primary-light); color: var(--primary);
            font-size: 11px; font-weight: 600; padding: 2px 8px; border-radius: 20px;
        }}
        /* ── Hero ── */
        .hero {{
            background: linear-gradient(135deg, #1e1b4b 0%, #312e81 50%, #4338ca 100%);
            color: white; padding: 48px 24px; text-align: center;
        }}
        .hero h1 {{ font-size: 28px; font-weight: 800; margin-bottom: 8px; }}
        .hero .keyword {{
            display: inline-block; background: rgba(255,255,255,0.15); border-radius: 8px;
            padding: 4px 16px; font-size: 16px; margin: 8px 0;
        }}
        .hero .date-range {{ font-size: 14px; opacity: 0.8; }}
        /* ── 统计卡片 ── */
        .stats-row {{
            display: flex; gap: 16px; padding: 24px; max-width: 960px; margin: -28px auto 0;
            position: relative; z-index: 10; flex-wrap: wrap; justify-content: center;
        }}
        .stat-card {{
            background: white; border-radius: var(--radius); padding: 20px 24px;
            box-shadow: 0 4px 12px rgba(0,0,0,0.08); flex: 1; min-width: 180px;
            display: flex; align-items: center; gap: 16px; border-left: 4px solid var(--p-color);
        }}
        .stat-icon {{ font-size: 32px; }}
        .stat-label {{ font-size: 13px; color: var(--text-secondary); }}
        .stat-num {{ font-size: 24px; font-weight: 800; color: var(--text); }}
        .stat-num small {{ font-size: 13px; font-weight: 400; color: var(--text-secondary); }}
        /* ── 主内容区 ── */
        .main {{ max-width: 960px; margin: 24px auto; padding: 0 24px; }}
        /* ── Tab ── */
        .tab-bar {{
            display: flex; gap: 4px; background: white; border-radius: var(--radius) var(--radius) 0 0;
            padding: 8px 8px 0; border: 1px solid var(--border); border-bottom: none;
        }}
        .tab-btn {{
            padding: 12px 24px; border: none; background: transparent;
            font-size: 15px; font-weight: 600; cursor: pointer; color: var(--text-secondary);
            border-radius: 8px 8px 0 0; transition: all 0.2s; position: relative;
        }}
        .tab-btn:hover {{ background: var(--bg); color: var(--tab-color); }}
        .tab-btn.active {{
            background: var(--bg); color: var(--tab-color);
        }}
        .tab-btn.active::after {{
            content: ''; position: absolute; bottom: 0; left: 20%; right: 20%;
            height: 3px; background: var(--tab-color); border-radius: 3px 3px 0 0;
        }}
        .tab-count {{
            font-size: 12px; background: var(--bg); padding: 2px 8px;
            border-radius: 10px; font-weight: 500; margin-left: 4px;
        }}
        .tab-btn.active .tab-count {{ background: var(--primary-light); color: var(--tab-color); }}
        /* ── 卡片列表 ── */
        .card-list {{ background: white; border: 1px solid var(--border); border-radius: 0 0 var(--radius) var(--radius); }}
        .card {{
            display: flex; gap: 16px; padding: 20px 24px;
            border-bottom: 1px solid #f3f4f6; transition: background 0.15s;
        }}
        .card:last-child {{ border-bottom: none; }}
        .card:hover {{ background: #fafbfc; }}
        .card-rank {{
            font-size: 20px; font-weight: 800; color: var(--card-accent);
            min-width: 32px; text-align: center; padding-top: 2px; opacity: 0.8;
        }}
        .card-body {{ flex: 1; min-width: 0; }}
        .card-title {{
            font-size: 16px; font-weight: 600; color: var(--text); text-decoration: none;
            line-height: 1.5; display: block; transition: color 0.15s;
        }}
        .card-title:hover {{ color: var(--card-accent); }}
        .card-meta {{ font-size: 13px; color: var(--text-secondary); margin-top: 6px; display: flex; align-items: center; gap: 0; flex-wrap: wrap; }}
        .author-link {{ color: var(--primary); text-decoration: none; font-weight: 500; transition: color 0.15s; }}
        .author-link:hover {{ color: var(--card-accent); text-decoration: underline; }}
        .author-name {{ color: var(--primary); font-weight: 500; }}
        .dot {{ margin: 0 6px; }}
        .card-desc {{ font-size: 14px; color: var(--text-secondary); line-height: 1.6; margin-top: 8px; display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical; overflow: hidden; }}
        .card-footer {{ display: flex; justify-content: space-between; align-items: center; margin-top: 10px; }}
        .engagement {{ display: flex; gap: 8px; flex-wrap: wrap; }}
        .eng-tag {{ font-size: 12px; color: var(--text-secondary); background: #f3f4f6; padding: 2px 8px; border-radius: 4px; }}
        .eng-tag.reads {{ background: #ecfdf5; color: #065f46; }}
        .view-btn {{
            font-size: 13px; color: var(--card-accent); text-decoration: none;
            font-weight: 500; white-space: nowrap; transition: opacity 0.15s;
        }}
        .view-btn:hover {{ opacity: 0.7; }}
        /* ── 其他 ── */
        .error-banner {{
            background: #fef3c7; color: #92400e; padding: 12px 16px;
            border-radius: 8px; margin: 16px 24px; font-size: 14px;
        }}
        .no-data-hint {{ text-align: center; color: var(--text-secondary); padding: 48px; }}
        /* ── 研究报告 ── */
        .report-section {{
            max-width: 960px; margin: 0 auto; padding: 0 24px;
        }}
        .section-title {{
            font-size: 20px; font-weight: 800; color: var(--text); margin-bottom: 16px;
            padding-bottom: 8px; border-bottom: 2px solid var(--primary);
        }}
        .report-content {{
            background: white; border: 1px solid var(--border); border-radius: var(--radius);
            padding: 32px; line-height: 1.8; color: var(--text); font-size: 15px;
        }}
        .report-content h2 {{ font-size: 20px; font-weight: 800; color: var(--primary); margin: 24px 0 12px; }}
        .report-content h3 {{ font-size: 18px; font-weight: 700; color: var(--text); margin: 20px 0 10px; }}
        .report-content h4 {{ font-size: 16px; font-weight: 700; color: var(--text); margin: 16px 0 8px; }}
        .report-content p {{ margin-bottom: 12px; }}
        .report-content strong {{ color: #1e1b4b; }}
        .report-content a {{ color: var(--primary); text-decoration: none; }}
        .report-content a:hover {{ text-decoration: underline; }}
        .report-content ul, .report-content ol {{ margin: 8px 0 12px 20px; }}
        .report-content li {{ margin-bottom: 4px; }}
        .report-content hr {{ border: none; border-top: 1px solid var(--border); margin: 20px 0; }}
        .footer {{
            text-align: center; color: var(--text-secondary); font-size: 12px;
            padding: 32px 24px; margin-top: 16px;
        }}
        .footer a {{ color: var(--primary); text-decoration: none; }}
        /* ── 响应式 ── */
        @media (max-width: 640px) {{
            .hero {{ padding: 32px 16px; }}
            .hero h1 {{ font-size: 20px; }}
            .stats-row {{ padding: 16px; margin-top: -20px; }}
            .stat-card {{ min-width: 140px; padding: 14px 16px; }}
            .stat-num {{ font-size: 20px; }}
            .main {{ padding: 0 12px; }}
            .card {{ padding: 14px 16px; gap: 10px; }}
            .card-rank {{ font-size: 16px; min-width: 24px; }}
            .card-title {{ font-size: 15px; }}
        }}
    </style>
</head>
<body>
    <nav class="navbar">
        <div class="logo">🇨🇳 cn<span>-last30days</span></div>
        <div class="badge">{VERSION}</div>
    </nav>
    <div class="hero">
        <h1>中国社媒话题研究</h1>
        <div class="keyword">{keyword}</div>
        <div class="date-range">{date_range["from"]} ~ {date_range["to"]}</div>
    </div>
    <div class="stats-row">
        {stats_html}
        <div class="stat-card" style="--p-color: var(--primary); --p-bg: var(--primary-light)">
            <div class="stat-icon">📊</div>
            <div class="stat-body">
                <div class="stat-label">合计</div>
                <div class="stat-num">{total} <small>条</small></div>
            </div>
        </div>
    </div>
    {report_section}
    <div class="main">
        <div class="tab-bar">
            {tabs_html}
        </div>
        {panels_html}
    </div>
    <div class="footer">
        数据来源：<a href="https://redfox.hk" target="_blank">redfox.hk</a> API · 小红书 / 抖音 / 公众号 · 近30天热门内容<br>
        互动数据为入库快照，实时数据可能持续增长
    </div>
    <script>
        document.querySelectorAll('.tab-btn').forEach(btn => {{
            btn.addEventListener('click', () => {{
                document.querySelectorAll('.tab-btn').forEach(b => b.classList.remove('active'));
                document.querySelectorAll('.tab-panel').forEach(p => p.style.display = 'none');
                btn.classList.add('active');
                document.getElementById('panel-' + btn.dataset.platform).style.display = 'block';
            }});
        }});
    </script>
</body>
</html>'''

    return html


# ─── CLI ─────────────────────────────────────────────────────────────────────────────
def main():
    parser = argparse.ArgumentParser(
        description="cn-last30days: 中国社媒平台话题研究工具"
    )
    parser.add_argument("keyword", nargs="?", default="dummy", help="搜索关键词（--from-json 模式下可省略）")
    parser.add_argument(
        "--platforms", "-p",
        default="xhs,dy,gzh",
        help="平台列表，逗号分隔（默认: xhs,dy,gzh）"
    )
    parser.add_argument(
        "--count", "-n",
        type=int,
        default=DEFAULT_COUNT,
        help=f"每个平台获取条数（默认: {DEFAULT_COUNT}）"
    )
    parser.add_argument(
        "--days", "-d",
        type=int,
        default=30,
        help="搜索时间范围，最近多少天（默认: 30，最大: 30）"
    )
    parser.add_argument(
        "--output-format", "-f",
        choices=["json", "html", "both"],
        default="json",
        help="输出格式（默认: json，综合报告后再按需生成HTML）"
    )
    parser.add_argument(
        "--output-dir",
        default=str(Path.home() / "Downloads" / "CnLast30Days"),
        help="HTML 输出目录"
    )
    parser.add_argument(
        "--api-key",
        default=None,
        help="API Key（覆盖环境变量和配置文件）"
    )
    parser.add_argument(
        "--max-items",
        type=int,
        default=50,
        help="输出中最多展示条数（默认: 50）"
    )
    parser.add_argument(
        "--from-json",
        default=None,
        help="从已有 JSON 文件生成 HTML，不调用 API（值: JSON 文件路径）"
    )
    parser.add_argument(
        "--report-file",
        default=None,
        help="研究报告 Markdown 文件路径（嵌入到 HTML 报告顶部）"
    )
    parser.add_argument(
        "--debug",
        action="store_true",
        help="调试模式，打印原始 API 响应"
    )

    args = parser.parse_args()

    # ── 从 JSON 生成 HTML 模式 ──
    if args.from_json:
        json_path = Path(args.from_json)
        if not json_path.exists():
            sys.stderr.write(f"错误: JSON 文件不存在: {json_path}\n")
            sys.exit(1)
        raw = json.loads(json_path.read_text(encoding="utf-8"))
        # 从精简 JSON 反向构造 data 结构
        data = {
            "keyword": raw.get("keyword", ""),
            "total_items": raw.get("total_items", 0),
            "date_range": raw.get("date_range", {}),
            "platforms": {},
        }
        for pkey, pdata in raw.get("platforms", {}).items():
            items = []
            for it in pdata.get("items", []):
                item = dict(it)
                item["source"] = pkey
                items.append(item)
            data["platforms"][pkey] = {
                "label": pdata.get("label", pkey),
                "total": pdata.get("total", len(items)),
                "items": items,
            }
        # 读取研究报告
        report_html = ""
        if args.report_file:
            report_path = Path(args.report_file)
            if report_path.exists():
                report_md = report_path.read_text(encoding="utf-8")
                report_html = _md_to_html(report_md)
            else:
                sys.stderr.write(f"⚠️ 报告文件不存在: {report_path}，跳过\n")
        html_content = format_as_html(data, max_items=args.max_items, report_html=report_html)
        output_dir = Path(args.output_dir)
        output_dir.mkdir(parents=True, exist_ok=True)
        base_name = json_path.stem  # 用原 JSON 文件名
        html_file = output_dir / f"{base_name}.html"
        html_file.write_text(html_content, encoding="utf-8")
        sys.stderr.write(f"✅ HTML 已保存: {html_file}\n")
        print(json.dumps({"files": {"html": str(html_file)}}, ensure_ascii=False))
        return

    # ── 正常搜索模式 ──
    # 解析平台列表
    platforms = []
    for p in args.platforms.split(","):
        p = p.strip().lower()
        if p in PLATFORMS:
            platforms.append(p)
        else:
            sys.stderr.write(f"未知平台: {p}，可用: {', '.join(PLATFORMS.keys())}\n")
    if not platforms:
        sys.stderr.write("错误: 未指定有效平台\n")
        sys.exit(1)

    # 执行搜索
    keyword = args.keyword.strip()
    if not keyword:
        sys.stderr.write("错误: 关键词不能为空\n")
        sys.exit(1)

    sys.stderr.write(f"\n{'='*60}\n")
    sys.stderr.write(f"cn-last30days · 搜索: {keyword}\n")
    sys.stderr.write(f"平台: {', '.join(PLATFORMS[p]['label'] for p in platforms)}\n")
    sys.stderr.write(f"每平台: {args.count} 条 | 时间: 近{args.days}天\n")
    sys.stderr.write(f"{'='*60}\n\n")
    sys.stderr.flush()

    try:
        data = search(
            keyword=keyword,
            platforms=platforms,
            count=args.count,
            api_key=args.api_key,
            days=args.days,
        )
    except Exception as e:
        sys.stderr.write(f"\n❌ 搜索失败: {e}\n")
        sys.exit(1)

    # 准备输出目录和文件名
    output_dir = Path(args.output_dir)
    output_dir.mkdir(parents=True, exist_ok=True)
    keyword_safe = keyword.replace('"', '').replace(' ', '_')[:30]
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    base_name = f"cn30days_{keyword_safe}_{timestamp}"

    # 保存 JSON
    json_file = None
    if args.output_format in ("json", "both"):
        json_data = format_as_json(data, max_items=args.max_items)
        json_file = output_dir / f"{base_name}.json"
        json_file.write_text(
            json.dumps(json_data, ensure_ascii=False, indent=2),
            encoding="utf-8",
        )
        sys.stderr.write(f"\n✅ JSON 已保存: {json_file}\n")

    # 保存 HTML
    html_file = None
    if args.output_format in ("html", "both"):
        html_content = format_as_html(data, max_items=args.max_items)
        html_file = output_dir / f"{base_name}.html"
        html_file.write_text(html_content, encoding="utf-8")
        sys.stderr.write(f"✅ HTML 已保存: {html_file}\n")

    # 统计（stderr，不影响 stdout）
    sys.stderr.write(f"\n{'='*60}\n")
    sys.stderr.write(f"搜索完成！共 {data['total_items']} 条结果\n")
    for pkey, pdata in data["platforms"].items():
        status = f"✅ {pdata['total']} 条" if not pdata.get("error") else f"❌ {pdata['error']}"
        sys.stderr.write(f"  {pdata['label']}: {status}\n")
    sys.stderr.write(f"{'='*60}\n")
    sys.stderr.write(f"{build_engine_footer(data['platforms'])}\n")
    sys.stderr.write(f"{'='*60}\n")
    sys.stderr.flush()

    # stdout 输出简洁摘要（供 AI 智能体解析，单行 JSON）
    summary = {
        "keyword": keyword,
        "date_range": data["date_range"],
        "total_items": data["total_items"],
        "platforms": {p: v["total"] for p, v in data["platforms"].items()},
        # 引擎页脚：供报告逐字粘贴（references/cn30-output-rules.md LAW 4）
        "engine_footer": build_engine_footer(data["platforms"]),
        "files": {},
    }
    if json_file:
        summary["files"]["json"] = str(json_file)
    if html_file:
        summary["files"]["html"] = str(html_file)
    print(json.dumps(summary, ensure_ascii=False))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
GEO 分析编排器 — 读取搜索结果，执行确定性分析，输出分析数据

用法:
    # Step 1: 仅确定性分析（Agent 执行 AI 分析前）
    python3 geo_analyze.py --brand "品牌名" --search-results output/search_results.json

    # 可选参数
    --aliases '["别名1","别名2"]'          品牌别名
    --competitors '["竞品A","竞品B"]'       已知竞品
    --ai-analysis output/ai_analysis.json   AI 分析结果（有则合并输出完整报告数据）

输出:
    output/deterministic.json       确定性分析结果
    output/ai_analysis_template.json  AI 分析模板（供 Agent 填充）
    output/analysis_result.json     合并后的完整分析（当提供 --ai-analysis 时）
"""

import sys
import os
import json
import argparse

sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "lib"))

from analyzer import (
    detect_all_mentions,
    extract_domains_from_sources,
    aggregate_domains,
    compute_mention_rate,
    build_mention_matrix,
    compute_per_answer_analysis,
    compute_aggregate_metrics,
    build_ai_analysis_template,
    build_analysis_prompt,
    merge_analysis,
    compute_sentiment_distribution,
    compute_brand_avg_rank,
    compute_competitor_metrics,
    compute_geo_score,
)
from platforms import PLATFORMS


def main():
    parser = argparse.ArgumentParser(description="GEO 分析编排器")
    parser.add_argument("--brand", required=True, help="品牌名称")
    parser.add_argument("--aliases", default="[]", help="品牌别名 JSON 列表")
    parser.add_argument("--competitors", default="[]", help="已知竞品 JSON 列表")
    parser.add_argument(
        "--search-results",
        default=os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "output", "search_results.json"),
        help="搜索结果 JSON 路径",
    )
    parser.add_argument(
        "--ai-analysis",
        default=None,
        help="AI 分析结果 JSON 路径（有则合并输出完整分析）",
    )
    parser.add_argument(
        "--output-dir",
        default=None,
        help="输出目录（默认 output/）",
    )
    args = parser.parse_args()

    # ── 解析参数 ──────────────────────────────────────────
    brand = args.brand
    aliases = json.loads(args.aliases) if args.aliases else []
    competitors = json.loads(args.competitors) if args.competitors else []

    # 品牌关键词 = 品牌名 + 别名
    brand_keywords = [brand] + aliases

    # 竞品关键词映射（默认竞品名就是关键词）
    competitor_map = {}
    for comp in competitors:
        competitor_map[comp] = [comp]

    output_dir = args.output_dir or os.path.join(
        os.path.dirname(os.path.abspath(__file__)), "..", "output"
    )
    os.makedirs(output_dir, exist_ok=True)

    # ── 读取搜索结果 ──────────────────────────────────────
    search_path = args.search_results
    if not os.path.exists(search_path):
        print(json.dumps({"error": f"搜索结果文件不存在: {search_path}"}, ensure_ascii=False))
        sys.exit(1)

    with open(search_path, "r", encoding="utf-8") as f:
        search_data = json.load(f)

    results = search_data.get("results", [])
    queries = search_data.get("queries", [])
    platforms = search_data.get("platforms", ["doubao", "kimi", "deepseek"])

    print(f"品牌: {brand}", file=sys.stderr)
    print(f"别名: {aliases}", file=sys.stderr)
    print(f"竞品: {competitors}", file=sys.stderr)
    print(f"搜索结果: {len(results)} 条，平台: {platforms}", file=sys.stderr)

    # ── Phase 1: 确定性分析 ────────────────────────────────
    print("\n执行确定性分析...", file=sys.stderr)

    per_answer = compute_per_answer_analysis(results, brand_keywords, competitor_map)
    metrics = compute_aggregate_metrics(per_answer, queries, platforms, brand, competitors)
    mention_matrix = build_mention_matrix(results, queries, platforms, brand_keywords)

    deterministic = {
        "brand": brand,
        "aliases": aliases,
        "competitors": competitors,
        "platforms": platforms,
        "queries": queries,
        "per_answer": per_answer,
        "metrics": metrics,
        "mention_matrix": mention_matrix,
    }

    det_path = os.path.join(output_dir, "deterministic.json")
    with open(det_path, "w", encoding="utf-8") as f:
        json.dump(deterministic, f, ensure_ascii=False, indent=2)
    print(f"确定性分析已保存: {det_path}", file=sys.stderr)

    # ── Phase 2: 生成 AI 分析模板 ──────────────────────────
    ai_template = build_ai_analysis_template(results, brand, competitors)

    template_path = os.path.join(output_dir, "ai_analysis_template.json")
    with open(template_path, "w", encoding="utf-8") as f:
        json.dump(ai_template, f, ensure_ascii=False, indent=2)
    print(f"AI 分析模板已保存: {template_path}", file=sys.stderr)

    # 输出 AI 分析提示
    print(f"\n{'='*60}", file=sys.stderr)
    print(f"AI 分析任务: 请对 {len(ai_template)} 份回答执行 AI 分析", file=sys.stderr)
    print(f"模板文件: {template_path}", file=sys.stderr)
    print(f"每份回答需填充字段: brand_rank, brand_context, sentiment,", file=sys.stderr)
    print(f"  sentiment_reason, competitors_mentioned, key_claims", file=sys.stderr)
    print(f"完成后保存为: {os.path.join(output_dir, 'ai_analysis.json')}", file=sys.stderr)
    print(f"然后重新运行本脚本添加 --ai-analysis 参数生成完整报告数据", file=sys.stderr)
    print(f"{'='*60}\n", file=sys.stderr)

    # ── Phase 3: 合并 AI 分析（如果提供）──────────────────
    if args.ai_analysis and os.path.exists(args.ai_analysis):
        print("检测到 AI 分析结果，开始合并...", file=sys.stderr)

        with open(args.ai_analysis, "r", encoding="utf-8") as f:
            ai_data = json.load(f)

        # 合并确定性 + AI 分析
        merged = merge_analysis(per_answer, ai_data)

        # 计算需要 AI 数据的指标
        sentiment_dist = compute_sentiment_distribution(merged, platforms)
        brand_avg_rank = compute_brand_avg_rank(merged, platforms)

        # 收集所有竞品（用户指定 + AI 发现）
        all_competitors = set(competitors)
        for ai in ai_data:
            for comp in ai.get("competitors_mentioned", []):
                all_competitors.add(comp)

        # 计算竞品指标（平均排名 + 情绪分布）
        competitor_metrics = compute_competitor_metrics(merged, platforms, all_competitors)

        # 计算 GEO 综合得分
        geo_score = {}
        geo_score["overall"] = compute_geo_score(
            metrics["brand_mention_rate"]["overall"],
            brand_avg_rank["overall"],
            sentiment_dist["overall"],
        )
        for p in platforms:
            geo_score[p] = compute_geo_score(
                metrics["brand_mention_rate"].get(p, 0),
                brand_avg_rank.get(p),
                sentiment_dist.get(p, {"positive": 0, "neutral": 0, "negative": 0}),
            )

        # 计算竞品提及率（覆盖所有竞品，含 AI 发现的）
        comp_mention_rates = {}
        for comp in all_competitors:
            rates = {"overall": 0.0}
            for p in platforms:
                rates[p] = 0.0
            total_done = 0
            total_hit = 0
            p_stats = {p: {"t": 0, "h": 0} for p in platforms}
            comp_lower = comp.lower()
            for ans in merged:
                if ans.get("status") != "completed":
                    continue
                p = ans.get("platform", "")
                total_done += 1
                p_stats.setdefault(p, {"t": 0, "h": 0})
                p_stats[p]["t"] += 1
                # 确定性匹配
                det_count = ans.get("competitor_mentions", {}).get(comp, 0)
                # AI 发现匹配（模糊匹配）
                ai_mentioned = False
                if det_count == 0:
                    for ai_comp in ans.get("ai_competitors_mentioned", []):
                        if comp_lower == ai_comp.lower() or comp_lower in ai_comp.lower() or ai_comp.lower() in comp_lower:
                            ai_mentioned = True
                            break
                if det_count > 0 or ai_mentioned:
                    total_hit += 1
                    p_stats[p]["h"] += 1
            rates["overall"] = total_hit / total_done if total_done > 0 else 0.0
            for p in platforms:
                ps = p_stats.get(p, {"t": 0, "h": 0})
                rates[p] = ps["h"] / ps["t"] if ps["t"] > 0 else 0.0
            comp_mention_rates[comp] = rates

        # 竞品对比矩阵
        competitor_comparison = []
        for comp in sorted(all_competitors):
            comp_rates = comp_mention_rates.get(comp, {"overall": 0})
            comp_m = competitor_metrics.get(comp, {})
            comp_avg_rank = comp_m.get("avg_rank", {})
            comp_sent = comp_m.get("sentiment", {})
            comp_sent_overall = comp_sent.get("overall", {"positive": 0, "neutral": 0, "negative": 0})
            comp_sent_total = sum(comp_sent_overall.values())
            competitor_comparison.append({
                "name": comp,
                "mention_rate_overall": comp_rates.get("overall", 0),
                "mention_rate_doubao": comp_rates.get("doubao", 0),
                "mention_rate_kimi": comp_rates.get("kimi", 0),
                "mention_rate_deepseek": comp_rates.get("deepseek", 0),
                "avg_rank": comp_avg_rank.get("overall"),
                "positive_pct": comp_sent_overall["positive"] / comp_sent_total if comp_sent_total > 0 else 0,
                "negative_pct": comp_sent_overall["negative"] / comp_sent_total if comp_sent_total > 0 else 0,
                "sentiment_dist": comp_sent_overall,
            })

        analysis_result = {
            "brand": brand,
            "aliases": aliases,
            "competitors": competitors,
            "discovered_competitors": list(all_competitors - set(competitors)),
            "all_competitors": sorted(all_competitors),
            "platforms": platforms,
            "queries": queries,
            "per_answer": merged,
            "metrics": metrics,
            "mention_matrix": mention_matrix,
            "sentiment_distribution": sentiment_dist,
            "brand_avg_rank": brand_avg_rank,
            "geo_score": geo_score,
            "competitor_comparison": competitor_comparison,
            "competitor_metrics": competitor_metrics,
        }

        result_path = os.path.join(output_dir, "analysis_result.json")
        with open(result_path, "w", encoding="utf-8") as f:
            json.dump(analysis_result, f, ensure_ascii=False, indent=2)
        print(f"完整分析结果已保存: {result_path}", file=sys.stderr)

        # stdout 输出摘要
        summary = {
            "brand": brand,
            "geo_score": geo_score,
            "mention_rate": metrics["brand_mention_rate"],
            "sentiment": sentiment_dist,
            "avg_rank": brand_avg_rank,
            "total_competitors": len(all_competitors),
            "output": result_path,
        }
        print(json.dumps(summary, ensure_ascii=False))
    else:
        # 无 AI 分析，仅输出确定性分析摘要
        summary = {
            "brand": brand,
            "deterministic_only": True,
            "mention_rate": metrics["brand_mention_rate"],
            "total_completed": metrics["total_completed"],
            "total_mentioned": metrics["total_mentioned"],
            "top_domains": list(metrics["domain_stats"].items())[:10],
            "deterministic_output": det_path,
            "ai_template_output": template_path,
            "next_step": "请根据 ai_analysis_template.json 对每份回答执行 AI 分析，保存为 ai_analysis.json 后重新运行",
        }
        print(json.dumps(summary, ensure_ascii=False))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
GEO 报告生成器 — 读取分析结果，生成交互式 HTML 报告

用法:
    python3 geo_report.py --analysis output/analysis_result.json

    # 可选: 附带原始搜索结果（用于原始回答存档模块）
    --search-results output/search_results.json

输出:
    output/geo_report.html
"""

import sys
import os
import json
import argparse
from datetime import datetime

sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "lib"))

from report_template import generate_html


def main():
    parser = argparse.ArgumentParser(description="GEO 报告生成器")
    parser.add_argument(
        "--analysis",
        default=os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "output", "analysis_result.json"),
        help="分析结果 JSON 路径",
    )
    parser.add_argument(
        "--search-results",
        default=os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "output", "search_results.json"),
        help="搜索结果 JSON 路径（可选，用于原始回答存档）",
    )
    parser.add_argument(
        "--output",
        default=None,
        help="输出 HTML 路径（默认 output/geo_report.html）",
    )
    args = parser.parse_args()

    # ── 读取分析结果 ──────────────────────────────────────
    if not os.path.exists(args.analysis):
        print(json.dumps({"error": f"分析结果文件不存在: {args.analysis}"}, ensure_ascii=False))
        sys.exit(1)

    with open(args.analysis, "r", encoding="utf-8") as f:
        analysis = json.load(f)

    # ── 读取搜索结果（可选）────────────────────────────────
    search_results = None
    if os.path.exists(args.search_results):
        with open(args.search_results, "r", encoding="utf-8") as f:
            search_results = json.load(f)

    # ── 生成 HTML ────────────────────────────────────────
    print("正在生成 HTML 报告...", file=sys.stderr)
    html_content = generate_html(analysis, search_results)

    # ── 写入文件 ─────────────────────────────────────────
    output_path = args.output or os.path.join(
        os.path.dirname(os.path.abspath(__file__)), "..", "output", "geo_report.html"
    )
    os.makedirs(os.path.dirname(os.path.abspath(output_path)), exist_ok=True)

    with open(output_path, "w", encoding="utf-8") as f:
        f.write(html_content)

    print(f"报告已生成: {output_path}", file=sys.stderr)

    # stdout 输出摘要
    brand = analysis.get("brand", "")
    geo_score = analysis.get("geo_score", {})
    summary = {
        "brand": brand,
        "output": output_path,
        "geo_score": geo_score,
        "generated_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
    }
    print(json.dumps(summary, ensure_ascii=False))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
GEO 搜索调度器 — 3平台 x N问题 批量提交 + 并行轮询

用法:
    python3 geo_search.py --queries '["问题1","问题2",...]' --platforms doubao,kimi,deepseek

输出:
    output/search_results.json

环境变量:
    REDFOX_API_KEY — 红狐 API Key（必填）
"""

import sys
import os
import json
import time
import argparse
from concurrent.futures import ThreadPoolExecutor, as_completed

# 将 lib 目录加入搜索路径
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "lib"))

from platforms import PLATFORMS, submit, poll, extract_result_full, is_valid_answer, API_KEY

POLL_INTERVAL = 5        # 轮询间隔（秒）
MAX_POLL_TIME = 900      # 最长等待 15 分钟（DeepSeek 深度搜索较慢）
MAX_WORKERS = 6          # 并发线程数（降低避免 Kimi 限流）
MAX_ANSWER_RETRY = 1     # 平台返回错误话术（限流/故障）时的重试次数


def main():
    parser = argparse.ArgumentParser(description="GEO 批量搜索调度器")
    parser.add_argument(
        "--queries",
        required=True,
        help='问题列表 JSON，如 \'["问题1","问题2"]\'',
    )
    parser.add_argument(
        "--platforms",
        default="doubao,kimi,deepseek",
        help="平台列表，逗号分隔（默认 doubao,kimi,deepseek）",
    )
    parser.add_argument(
        "--output",
        default=None,
        help="输出文件路径（默认 output/search_results.json）",
    )
    args = parser.parse_args()

    # ── 前置检查 ──────────────────────────────────────────
    if not API_KEY:
        result = {
            "error": (
                "未配置 REDFOX_API_KEY 环境变量，"
                "请前往 https://redfox.hk/settings/api-keys?source=github 获取 API Key"
            )
        }
        print(json.dumps(result, ensure_ascii=False))
        sys.exit(1)

    queries = json.loads(args.queries)
    platforms = [p.strip() for p in args.platforms.split(",") if p.strip()]

    for p in platforms:
        if p not in PLATFORMS:
            print(json.dumps({"error": f"未知平台: {p}，可选: {list(PLATFORMS.keys())}"}, ensure_ascii=False))
            sys.exit(1)

    total = len(queries) * len(platforms)
    output_path = args.output or os.path.join(
        os.path.dirname(os.path.abspath(__file__)), "..", "output", "search_results.json"
    )
    os.makedirs(os.path.dirname(os.path.abspath(output_path)), exist_ok=True)

    print(f"开始搜索: {len(queries)} 个问题 x {len(platforms)} 个平台 = {total} 个任务", file=sys.stderr)

    # ── Phase 1: 批量提交所有任务 ──────────────────────────
    tasks = []  # [{query, platform, query_index, task_id | error}]

    with ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
        future_map = {}
        for qi, query in enumerate(queries):
            for platform in platforms:
                future = executor.submit(submit, platform, query)
                future_map[future] = {
                    "query": query,
                    "platform": platform,
                    "query_index": qi,
                }

        for future in as_completed(future_map):
            info = future_map[future]
            try:
                task_id = future.result()
                info["task_id"] = task_id
                print(f"  [提交] {info['platform']} Q{info['query_index']+1} -> {task_id}", file=sys.stderr)
            except Exception as e:
                info["task_id"] = None
                info["error"] = str(e)
                print(f"  [提交失败] {info['platform']} Q{info['query_index']+1} -> {e}", file=sys.stderr)
            tasks.append(info)

    submitted_ok = [t for t in tasks if t.get("task_id")]
    print(f"\n提交完成: {len(submitted_ok)}/{total} 成功，开始轮询...\n", file=sys.stderr)

    # ── Phase 2: 并行轮询所有任务 ──────────────────────────
    results = []
    pending = list(submitted_ok)
    max_attempts = MAX_POLL_TIME // POLL_INTERVAL

    for attempt in range(1, max_attempts + 1):
        if not pending:
            break

        time.sleep(POLL_INTERVAL)

        still_pending = []
        completed_this_round = 0

        with ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
            future_map = {}
            for task in pending:
                future = executor.submit(poll, task["platform"], task["task_id"])
                future_map[future] = task

            for future in as_completed(future_map):
                task = future_map[future]
                try:
                    raw = future.result()
                    if raw is not None:
                        # 任务完成 —— 先校验是否为真实回答
                        ex = extract_result_full(task["platform"], raw)
                        valid, reason = is_valid_answer(ex["content"])

                        if not valid:
                            retries = task.get("answer_retry", 0)
                            if retries < MAX_ANSWER_RETRY:
                                # 平台限流/故障话术，重新提交一次
                                try:
                                    task["task_id"] = submit(task["platform"], task["query"])
                                    task["answer_retry"] = retries + 1
                                    still_pending.append(task)
                                    print(
                                        f"  [重试] {task['platform']} Q{task['query_index']+1}"
                                        f" -> {reason}，已重新提交",
                                        file=sys.stderr,
                                    )
                                except Exception as e:
                                    results.append({
                                        "question": task["query"],
                                        "query_index": task["query_index"],
                                        "platform": task["platform"],
                                        "content": "",
                                        "sources": [],
                                        "status": "invalid",
                                        "error": f"{reason}；重试提交失败: {e}",
                                    })
                                    print(
                                        f"  [无效] {task['platform']} Q{task['query_index']+1}"
                                        f" -> {reason}",
                                        file=sys.stderr,
                                    )
                                continue

                            # 重试后仍无效：标记 invalid，排除出统计（不计入分母）
                            results.append({
                                "question": task["query"],
                                "query_index": task["query_index"],
                                "platform": task["platform"],
                                "content": "",
                                "sources": [],
                                "status": "invalid",
                                "error": reason,
                            })
                            completed_this_round += 1
                            print(
                                f"  [无效] {task['platform']} Q{task['query_index']+1}"
                                f" -> {reason}（已排除出统计）",
                                file=sys.stderr,
                            )
                            continue

                        entry = {
                            "question": task["query"],
                            "query_index": task["query_index"],
                            "platform": task["platform"],
                            "content": ex["content"],
                            "sources": ex["sources"],
                            "sources_available": ex["sources_available"],
                            "status": "completed",
                        }
                        if ex["sources_note"]:
                            entry["sources_note"] = ex["sources_note"]
                        results.append(entry)
                        completed_this_round += 1
                        print(f"  [完成] {task['platform']} Q{task['query_index']+1}", file=sys.stderr)
                    else:
                        still_pending.append(task)
                except Exception as e:
                    results.append({
                        "question": task["query"],
                        "query_index": task["query_index"],
                        "platform": task["platform"],
                        "content": "",
                        "sources": [],
                        "status": "failed",
                        "error": str(e),
                    })
                    print(f"  [失败] {task['platform']} Q{task['query_index']+1} -> {e}", file=sys.stderr)

        pending = still_pending
        if pending:
            print(f"  轮询 {attempt}: 本轮完成 {completed_this_round}，剩余 {len(pending)} 等待中...", file=sys.stderr)

    # 处理超时任务
    for task in pending:
        results.append({
            "question": task["query"],
            "query_index": task["query_index"],
            "platform": task["platform"],
            "content": "",
            "sources": [],
            "status": "timeout",
        })

    # 处理提交失败的任务
    for task in tasks:
        if task.get("task_id") is None:
            results.append({
                "question": task["query"],
                "query_index": task["query_index"],
                "platform": task["platform"],
                "content": "",
                "sources": [],
                "status": "submit_failed",
                "error": task.get("error", "Unknown"),
            })

    # 按 query_index + platform 排序
    platform_order = {p: i for i, p in enumerate(platforms)}
    results.sort(key=lambda r: (r.get("query_index", 0), platform_order.get(r.get("platform", ""), 99)))

    output = {
        "queries": queries,
        "platforms": platforms,
        "total_tasks": total,
        "completed": len([r for r in results if r["status"] == "completed"]),
        "invalid": len([r for r in results if r["status"] == "invalid"]),
        "failed": len([r for r in results if r["status"] not in ("completed", "invalid")]),
        "results": results,
    }

    with open(output_path, "w", encoding="utf-8") as f:
        json.dump(output, f, ensure_ascii=False, indent=2)

    summary = f"\n搜索完成: {output['completed']}/{total} 条有效"
    if output["invalid"]:
        summary += f"，{output['invalid']} 条平台异常已排除"
    if output["failed"]:
        summary += f"，{output['failed']} 条失败"
    print(summary, file=sys.stderr)
    print(f"结果已保存: {output_path}", file=sys.stderr)

    # stdout 输出 JSON 供 Agent 解析
    print(json.dumps(output, ensure_ascii=False))


if __name__ == "__main__":
    main()

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
热点数据获取脚本
从热点接口获取各平台热点数据，支持时间范围查询和关键词筛选
"""

import argparse
import json
import os
import ssl
import sys
import urllib.request
from datetime import datetime, timedelta
from typing import Dict, List, Optional
import tempfile

# 平台代码映射：平台代码 -> 平台名称
PLATFORM_MAP = {
    "wb": "微博",
    "dy": "抖音",
    "bz": "B站",
    "ks": "快手",
    "zh": "知乎",
    "tt": "头条",
    "bd": "百度"
}

# 平台代码到接口枚举值的映射
PLATFORM_CODE_MAP = {
    "ks": 1,   # 快手
    "dy": 2,   # 抖音
    "wb": 5,   # 微博
    "bd": 7,   # 百度
    "bz": 8,   # B站
    "zh": 9,   # 知乎
    "tt": 10   # 头条
}

# 平台展示固定顺序（与 SKILL.md 输出规范一致）
# 百度 → 知乎 → 微博 → 抖音 → B站 → 快手 → 头条
DISPLAY_ORDER = ["bd", "zh", "wb", "dy", "bz", "ks", "tt"]

# 关键词泛化映射：大词 -> 泛化词列表
KEYWORD_EXPANSION_MAP = {
    "体育": ["体育", "足球", "篮球", "运动", "健身", "奥运", "世界杯", "NBA", "CBA", "乒乓球"],
    "娱乐": ["娱乐", "明星", "电影", "电视剧", "综艺", "音乐", "八卦"],
    "科技": ["科技", "互联网", "手机", "电脑", "AI", "人工智能", "数码"],
    "财经": ["财经", "股市", "基金", "理财", "经济", "金融"],
    "社会": ["社会", "民生", "新闻", "热点", "事件"],
    "游戏": ["游戏", "电竞", "网游", "手游", "王者荣耀", "英雄联盟"],
    "汽车": ["汽车", "车", "新能源", "电动车", "特斯拉", "比亚迪"],
    "美食": ["美食", "吃", "餐厅", "菜谱", "做饭"],
    "旅游": ["旅游", "旅行", "景点", "攻略", "酒店"],
    "时尚": ["时尚", "穿搭", "美妆", "护肤", "衣服"]
}


def expand_keywords(keyword: str) -> List[str]:
    """
    对关键词进行泛化扩展

    Args:
        keyword: 用户输入的关键词

    Returns:
        扩展后的关键词列表
    """
    # 首先检查是否为大词（优先匹配）
    for big_word, expanded_words in KEYWORD_EXPANSION_MAP.items():
        if keyword == big_word or big_word in keyword:
            return expanded_words

    # 精确词不扩展（长度<=2或包含特定字符）
    if len(keyword) <= 2 or any(char in keyword for char in ["超", "联赛", "杯"]):
        return [keyword]

    # 默认不扩展
    return [keyword]


def format_hot_count(hot_count: str) -> str:
    """
    智能格式化热度值

    Args:
        hot_count: 原始热度值

    Returns:
        格式化后的热度值
    """
    if not hot_count:
        return "0"

    # 如果已经包含单位（万、亿），直接返回
    if "万" in hot_count or "亿" in hot_count:
        return hot_count

    # 尝试转换为数字
    try:
        num = int(hot_count)
        # 转换为"数字+万"格式
        wan = num // 10000
        if wan > 0:
            return f"{wan}万"
        else:
            return str(num)
    except ValueError:
        # 无法转换为数字，直接返回原值
        return hot_count


def _get_api_key() -> str:
    """从当前环境变量获取 REDFOX_API_KEY"""
    key = os.environ.get("REDFOX_API_KEY")
    if not key:
        raise SystemExit("❌ 未找到 REDFOX_API_KEY，请配置环境变量：export REDFOX_API_KEY=<你的apikey>")
    return key


def fetch_hotspot_data(
    source: str,
    platforms: Optional[List[str]] = None,
    keywords: Optional[List[str]] = None,
    start_date: Optional[str] = None,
    end_date: Optional[str] = None
) -> Dict:
    """
    从接口获取热点数据

    Args:
        source: 数据来源
        platforms: 平台代码列表（可选）
        keywords: 关键词列表（可选）
        start_date: 开始时间（可选）
        end_date: 结束时间（可选）

    Returns:
        API返回的数据字典
    """
    # API配置
    api_url = "https://redfox.hk/story/api/hotSpot/getListByPlatformWithKeyword"

    # 构建请求参数
    params = {
        "source": source
    }

    # 添加平台参数（数组）- 始终传入，即使为空数组
    platform_enums = []
    if platforms:
        for p in platforms:
            if p in PLATFORM_CODE_MAP:
                platform_enums.append(PLATFORM_CODE_MAP[p])
            else:
                print(f"警告: 不支持的平台代码 {p}", file=sys.stderr)
    params["platforms"] = platform_enums

    # 添加关键词参数（数组）- 始终传入，即使为空数组
    params["keywords"] = keywords if keywords else []

    # 添加时间参数
    if start_date:
        params["startDate"] = start_date
    if end_date:
        params["endDate"] = end_date

    # 获取 API Key
    api_key = _get_api_key()

    try:
        # 发送请求（使用 urllib，跳过 SSL 验证）
        body = json.dumps(params).encode("utf-8")
        req = urllib.request.Request(
            api_url,
            data=body,
            headers={
                "Content-Type": "application/json",
                "X-API-KEY": api_key
            },
            method="POST"
        )
        ctx = ssl.create_default_context()
        ctx.check_hostname = False
        ctx.verify_mode = ssl.CERT_NONE
        with urllib.request.urlopen(req, timeout=30, context=ctx) as resp:
            if resp.status != 200:
                return {
                    "status": "error",
                    "message": f"HTTP请求失败: {resp.status}",
                    "data": None
                }
            raw = resp.read()

        # 解析响应
        result = json.loads(raw.decode("utf-8"))

        # 接口返回code=2000表示成功
        if result.get("code") == 2000:
            return {
                "status": "success",
                "message": "数据获取成功",
                "data": result.get("data", {})
            }
        else:
            # 接口返回错误码
            error_msg = result.get("msg") or result.get("message") or "接口返回错误"
            return {
                "status": "error",
                "message": f"接口错误: {error_msg} (code: {result.get('code')})",
                "data": None
            }

    except Exception as e:
        err_msg = str(e)
        if "timed out" in err_msg.lower():
            return {"status": "error", "message": "请求超时", "data": None}
        if "urlopen" in err_msg.lower() or "connection" in err_msg.lower():
            return {"status": "error", "message": f"连接失败: {err_msg}", "data": None}
        return {"status": "error", "message": f"请求异常: {err_msg}", "data": None}


def process_hotspot_data(data: Dict, platform_filter: Optional[List[str]] = None) -> Dict:
    """
    处理热点数据

    Args:
        data: API返回的原始数据
        platform_filter: 平台筛选列表

    Returns:
        处理后的数据
    """
    result = {
        "total": 0,
        "platforms": {}
    }

    # 平台列表映射
    platform_list_map = {
        "bdList": "bd",
        "bzList": "bz",
        "dyList": "dy",
        "ksList": "ks",
        "ttList": "tt",
        "wbList": "wb",
        "zhList": "zh"
    }

    for list_key, platform_code in platform_list_map.items():
        # 如果指定了平台筛选，跳过不在筛选列表中的平台
        if platform_filter and platform_code not in platform_filter:
            continue

        hotspots = data.get(list_key, [])
        if hotspots:
            processed_hotspots = []
            for hotspot in hotspots:
                processed = {
                    "title": hotspot.get("title", ""),
                    "url": hotspot.get("url", ""),
                    "hotCount": format_hot_count(hotspot.get("hotCount", "0")),
                    "index": hotspot.get("index", 0),
                    "gmtCreate": hotspot.get("gmtCreate", ""),
                    "platCode": platform_code,
                    "platName": PLATFORM_MAP.get(platform_code, platform_code)
                }
                processed_hotspots.append(processed)

            result["platforms"][platform_code] = {
                "name": PLATFORM_MAP.get(platform_code, platform_code),
                "count": len(processed_hotspots),
                "hotspots": processed_hotspots
            }
            result["total"] += len(processed_hotspots)

    return result


def ordered_platforms(result: Dict):
    """按固定展示顺序返回 (platform_code, platform_data) 列表

    API 返回顺序不稳定（实测为 百度/B站/抖音/快手/头条/微博/知乎），
    这里统一重排为 SKILL.md 规定的顺序；未知平台码追加在末尾。
    """
    platforms = result.get("platforms", {})
    ordered = [(c, platforms[c]) for c in DISPLAY_ORDER if c in platforms]
    ordered += [(c, d) for c, d in platforms.items() if c not in DISPLAY_ORDER]
    return ordered


def output_compact(result: Dict) -> str:
    """
    输出极简格式（避免数据被截断）
    末尾附带完整数据文件路径，避免重复调用接口
    """
    output_lines = []

    # 元信息
    output_lines.append(f"status: {result['status']}")
    output_lines.append(f"total: {result['total']}")
    output_lines.append(f"platforms: {len(result['platforms'])}")
    output_lines.append("")

    # 各平台概览（每平台仅预览 TOP3，完整数据见 dataFile）
    for platform_code, platform_data in ordered_platforms(result):
        total_n = platform_data["count"]
        preview_n = min(3, total_n)
        output_lines.append(f"[{platform_data['name']}] {total_n}条（下表为 TOP{preview_n} 预览）")
        for hotspot in platform_data["hotspots"][:3]:
            output_lines.append(f"  {hotspot['index']}. {hotspot['title']} - {hotspot['hotCount']}")
        output_lines.append("")

    # 附带完整数据文件路径（一次调用搞定，禁止二次调用浪费token）
    if "dataFile" in result:
        output_lines.append(f"dataFile: {result['dataFile']}")

    return "\n".join(output_lines)


def output_json(result: Dict) -> str:
    """
    输出JSON格式
    """
    return json.dumps(result, ensure_ascii=False, indent=2)


def output_markdown(result: Dict) -> str:
    """
    输出Markdown表格格式（只输出TOP10）
    """
    output_lines = []

    for platform_code, platform_data in ordered_platforms(result):
        output_lines.append(f"## {platform_data['name']}")
        output_lines.append("")
        output_lines.append("|排名|标题|热度|")
        output_lines.append("|---|---|---|")

        for hotspot in platform_data["hotspots"][:10]:
            title = hotspot["title"]
            url = hotspot["url"]
            hot_count = hotspot["hotCount"]
            index = hotspot["index"]

            # Markdown超链接格式
            title_link = f"[{title}]({url})" if url else title
            output_lines.append(f"|{index}|{title_link}|{hot_count}|")

        output_lines.append("")

    return "\n".join(output_lines)


def main():
    parser = argparse.ArgumentParser(description="获取各平台热点数据")

    parser.add_argument(
        "--source",
        default="全平台热点事件-GitHub",
        help="数据来源（默认：全平台热点事件）"
    )

    parser.add_argument(
        "--platforms",
        help="平台代码列表，逗号分隔（如：wb,dy,bz）"
    )

    parser.add_argument(
        "--keywords",
        help="关键词列表，逗号分隔（如：体育,足球）"
    )

    parser.add_argument(
        "--expand-keywords",
        action="store_true",
        help="启用关键词泛化扩展"
    )

    parser.add_argument(
        "--start-date",
        help="开始时间（格式：YYYY-MM-DD HH:MM:SS）"
    )

    parser.add_argument(
        "--end-date",
        help="结束时间（格式：YYYY-MM-DD HH:MM:SS）"
    )

    parser.add_argument(
        "--output",
        choices=["compact", "json", "markdown"],
        default="compact",
        help="输出格式（默认：compact）"
    )

    args = parser.parse_args()

    # 解析平台参数
    platforms = None
    if args.platforms:
        platforms = [p.strip() for p in args.platforms.split(",")]

    # 解析关键词参数
    keywords = None
    if args.keywords:
        raw_keywords = [k.strip() for k in args.keywords.split(",")]
        if args.expand_keywords:
            # 对每个关键词进行扩展
            expanded = []
            for k in raw_keywords:
                expanded.extend(expand_keywords(k))
            keywords = list(dict.fromkeys(expanded))  # 去重保持顺序
        else:
            keywords = raw_keywords

    # 计算默认时间范围（前一个完整小时）
    if not args.start_date or not args.end_date:
        now = datetime.now()
        current_hour = now.replace(minute=0, second=0, microsecond=0)
        start_time = current_hour - timedelta(hours=1)
        end_time = current_hour

        if not args.start_date:
            args.start_date = start_time.strftime("%Y-%m-%d %H:%M:%S")
        if not args.end_date:
            args.end_date = end_time.strftime("%Y-%m-%d %H:%M:%S")

    # 获取数据
    api_result = fetch_hotspot_data(
        source=args.source,
        platforms=platforms,
        keywords=keywords,
        start_date=args.start_date,
        end_date=args.end_date
    )

    if api_result["status"] == "error":
        print(json.dumps(api_result, ensure_ascii=False))
        sys.exit(1)

    # 处理数据
    result = process_hotspot_data(api_result["data"], platforms)

    # 添加元信息
    result["status"] = "success"
    result["source"] = args.source
    result["startDate"] = args.start_date
    result["endDate"] = args.end_date
    if keywords:
        result["keywords"] = keywords

    # 保存完整数据到临时文件
    temp_file = tempfile.mktemp(prefix="platforms-hotspot-data-", suffix=".json")
    with open(temp_file, "w", encoding="utf-8") as f:
        json.dump(result, f, ensure_ascii=False, indent=2)
    result["dataFile"] = temp_file

    # 输出结果
    if args.output == "compact":
        print(output_compact(result))
    elif args.output == "json":
        print(output_json(result))
    elif args.output == "markdown":
        print(output_markdown(result))


if __name__ == "__main__":
    main()