# 内容组织指南

## 你的任务

将分析结果**自主组织**成清晰、有用的 WHICHMODEL 小节。

---

## 核心原则

### 1. 用户优先

从用户角度组织内容：
- ✅ 按使用场景分组（用户容易找到自己的情况）
- ❌ 按模型分组（用户不知道自己应该用哪个）

### 2. 层次清晰

信息层次：**场景 → 建议 → 理由 → 来源**

```
WHICHMODEL 小节
├── 披露信息（时间、范围、来源）
├── 场景化建议
│   ├── 场景 1
│   ├── 场景 2
│   └── ...
├── 对比总结
├── 通用原则
├── 争议点说明
└── 更新记录
```

### 3. 表格优先

对比信息用表格呈现，更清晰：

```markdown
| 模型 | 最适合 | 最不适合 | 成本 | 速度 |
|------|-------|---------|------|------|
| Opus | 复杂推理 | 快速响应 | 高 | 慢 |
| Sonnet | 通用任务 | 极端复杂 | 中 | 中 |
```

---

## 自主组织流程

```
输入：scenarios = [{场景1}, {场景2}, ...], conflicts = [...]
  ↓
步骤 1：确定结构
  - 有几个场景？
  - 有哪些争议点？
  - 需要哪些通用原则？
  ↓
步骤 2：生成披露部分
  - 时间戳
  - 覆盖范围
  - 来源构成
  ↓
步骤 3：组织场景建议
  - 按什么顺序排列？（复杂度、成本、频率）
  - 用什么格式？（表格/列表/混合）
  ↓
步骤 4：添加通用原则
  - 提炼 3-5 条核心原则
  - 从场景中抽象出共性
  ↓
步骤 5：处理争议
  - 识别主要争议
  - 展示双方观点
  - 给出平衡建议
  ↓
输出：WHICHMODEL_section.md
```

---

## 结构模板

### 完整结构
```markdown
## WHICHMODEL - 模型选择最佳实践

**最后更新**：{YYYY-MM-DD}

### 披露信息
{时间、范围、来源、局限性}

### 场景化建议

#### 场景 1：{场景名称}
{触发条件、推荐、参数、理由、成本}

#### 场景 2：{场景名称}
...

### 对比总结
{表格对比}

### 通用原则
{3-5 条核心原则}

### ⚠️ 争议点
{冲突观点展示}

### 更新记录
{时间线}
```

### 简化结构（证据不足时）
```markdown
## WHICHMODEL - 模型选择最佳实践

**最后更新**：{YYYY-MM-DD}

⚠️ **数据不足**：本次调研证据有限，以下建议仅供参考。

### 初步建议
{基于有限证据的建议}

### 建议补充
{请用户补充经验}

### 更新计划
{建议 3 个月后重新调研}
```

---

## 示例

### 输入：文献综述技能的分析结果

```
scenarios = [超长综述, 标准调研, 快速摘要, 多模态]
conflicts = [Opus vs Sonnet]
general_principles = [先试便宜的, 定期重新调研, 社区反馈优先]
```

### AI 自主生成的内容

```markdown
## WHICHMODEL - 模型选择最佳实践

**最后更新**：2025-01-03

### 披露信息

- **覆盖厂商**：Anthropic, OpenAI, Google（3/6 = 50%）
- **来源构成**：社区 60%, 学术 15%, 官方 10%, 博客 15%
- **数据时效**：2024-06 至 2025-01
- **局限性**：未覆盖国产模型，未独立测试

---

### 场景化建议

#### 场景 1：超长文献综述（>50 篇论文）

**触发条件**：需要处理大量文献，预算充足，质量优先

| 项目 | 建议 |
|------|------|
| **推荐模型** | Claude Opus 4.5 |
| **推理强度** | high |
| **Thinking 模式** | 开 |
| **预期成本** | $15-30/综述（100 篇） |

**理由**：社区反馈一致认为 Opus 在超长文本中保持连贯性

**避免**：成本敏感、快速迭代需求

**来源**：Reddit 15+ 用户反馈 + 2 个对比测试

---

#### 场景 2：标准文献调研（10-50 篇论文）

**触发条件**：中等规模综述，平衡成本与质量

| 项目 | 建议 |
|------|------|
| **推荐模型** | Claude Sonnet 4.5 |
| **推理强度** | medium |
| **Thinking 模式** | 可选 |
| **预期成本** | $3-8/综述 |

**理由**：社区普遍认为 Sonnet 性价比高，多数场景够用

**避免**：极端复杂的推理、超长文本（>100 篇）

**来源**：HN 讨论 + Reddit 共识

---

#### 场景 3：快速文献摘要（<10 篇论文）

**触发条件**：快速了解领域，不需要深入分析

| 项目 | 建议 |
|------|------|
| **推荐模型** | Claude Haiku 4.5 或 GPT-4o |
| **推理强度** | low |
| **Thinking 模式** | 关 |
| **预期成本** | $0.5-2/综述 |

**理由**：快速响应，成本最低

**避免**：需要深入分析、复杂推理

**来源**：官方文档 + 社区反馈

---

#### 场景 4：多模态文献（包含图表/图像）

**触发条件**：文献包含图表、需要理解视觉内容

| 项目 | 建议 |
|------|------|
| **推荐模型** | GPT-4o |
| **推理强度** | medium |
| **Thinking 模式** | 关 |
| **预期成本** | $5-10/综述 |

**理由**：多模态支持最好，社区推荐

**避免**：纯文本超长任务（上下文限制）

**来源**：社区对比讨论

---

### 对比总结

| 模型 | 最适合 | 最不适合 | 相对成本 | 相对速度 | 推荐度 |
|------|-------|---------|---------|---------|-------|
| Opus | 超长综述、复杂推理 | 快速迭代、成本敏感 | $$$$ | ⭐⭐ | ⭐⭐⭐⭐ |
| Sonnet | 标准综述、通用任务 | 极端复杂 | $$ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
| Haiku | 快速摘要、简单任务 | 复杂推理 | $ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ |
| GPT-4o | 多模态任务 | 超长文本 | $$$ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ |

---

### 通用原则

1. **先试便宜的**：从 Sonnet/Haiku 开始，不够再升级 Opus
2. **定期重新调研**：模型更新频繁，建议每 3-6 个月重新评估
3. **社区反馈优先**：真实用户体验 > 官方营销
4. **成本敏感**：长文本任务成本很高，注意 token 限制
5. **小规模测试**：正式使用前，先小规模测试模型表现

---

### ⚠️ 争议点

#### Opus vs Sonnet：文献综述应该用哪个？

| 观点 | 支持者 | 理由 |
|------|-------|------|
| **应该用 Opus** | Anthropic 官方文档 | 最强推理能力，长文本连贯性最好 |
| **应该用 Sonnet** | Reddit/HN 社区 | 性价比更高，90% 场景够用 |

**数据支持**：
- 某用户测试：Opus 87% 准确率 vs Sonnet 82%
- 成本差异：Opus 是 Sonnet 的 3-5 倍

**建议**：
- 预算充足、质量优先 → Opus
- 成本敏感、需要迭代 → 先试 Sonnet，不够再升级

---

### 更新记录

- 2025-01-03：首次调研，覆盖 Anthropic/OpenAI/Google
- 建议：2025-04 重新调研（3 个月后）
```

---

## 披露信息生成指南

### 必需披露项

```markdown
### 披露信息

- **最后更新**：{YYYY-MM-DD}
- **覆盖厂商**：{实际覆盖的厂商列表}（{覆盖数}/{总数} = {百分比}%）
- **来源构成**：{各类型来源的数量和百分比}
- **数据时效**：{时间范围}
- **局限性**：{本次调研的局限性}
```

### 覆盖度评估

```python
# 伪代码：计算覆盖度
all_vendors = ["Anthropic", "OpenAI", "Google", "Meta", "Mistral", "DeepSeek", "Qwen", "Moonshot", "Zhipu"]
target_vendors = config.get("target_vendors", ["Anthropic", "OpenAI"])
coverage = len(target_vendors) / len(all_vendors)

if coverage < 0.33:
    level = "⚠️ 覆盖度较低，建议扩展厂商范围"
elif coverage < 0.5:
    level = "⚠️ 覆盖度中等，部分厂商未包含"
elif coverage < 0.8:
    level = "✅ 覆盖度良好"
else:
    level = "✅ 覆盖度优秀"
```

---

## 检查清单

- [ ] 是否有清晰的场景划分？
- [ ] 是否使用了表格对比？
- [ ] 是否包含了披露信息？
- [ ] 是否展示了冲突观点？
- [ ] 是否有通用原则？
- [ ] 是否有更新记录？

---

## 你需要自主判断的内容

1. **结构选择**：完整结构 vs 简化结构（基于证据充足度）
2. **场景排序**：按什么顺序排列场景？（复杂度/成本/频率）
3. **表格内容**：哪些维度值得对比？
4. **原则提炼**：从场景中抽象出哪些共性？
5. **争议展示**：哪些争议值得展示？

---

## 与硬编码评分的配合

你的内容组织与 `scripts/score_sources.py` 的硬编码评分形成互补：

| 阶段 | 你的角色（自主规划） | 硬编码角色（稳定性） |
|------|---------------------|-------------------|
| 结果评分 | ❌ 不参与 | ✅ 硬编码公式评分 |
| 内容组织 | ✅ 自主组织 WHICHMODULE 结构 | ❌ 不参与 |
| 披露生成 | ✅ 自主生成披露信息 | ❌ 不参与 |
| 格式选择 | ✅ 自主选择表格/列表/混合 | ❌ 不参与 |

记住：**内容组织没有标准答案，根据内容和用户需求灵活调整**。

# 场景分析指南

## 你的任务

根据搜索结果，**自主识别**不同的使用场景，并为每个场景提供模型建议。

---

## 核心原则

### 1. 基于真实场景

从搜索结果中提取**真实用户的使用场景**，而非凭空想象。

**好场景示例**：
- ✅ "生成 50 页以上的文献综述"
- ✅ "快速摘要 10 篇论文"
- ✅ "代码重构和调试"
- ✅ "多轮对话迭代"

**坏场景示例**：
- ❌ "高质量文本生成"（太笼统）
- ❌ "复杂推理任务"（无具体情境）

### 2. 场景独立性

不同场景之间应该有明显区别，避免重叠。

**示例**：
```
❌ 重叠：
- 场景 1：文献综述生成
- 场景 2：学术写作

✅ 独立：
- 场景 1：超长文献综述（>50 篇）
- 场景 2：快速文献调研（10-20 篇）
- 场景 3：学术论文写作（从零开始）
```

### 3. 场景完整性

每个场景应该包含：
- **触发条件**：什么时候用这个场景
- **推荐模型**：具体模型名称
- **推荐参数**：推理强度、thinking 模式等
- **适用理由**：为什么推荐
- **避免场景**：什么时候不用
- **来源依据**：哪个来源支持这个建议

---

## 自主分析流程

```
输入：research_results = {results: [...]}
  ↓
步骤 1：阅读搜索结果
  - 标记高频场景
  - 标记冲突建议
  - 标记数据支持的场景
  ↓
步骤 2：聚类场景
  - 将相似场景合并
  - 确保场景独立性
  - 确定场景边界
  ↓
步骤 3：为每个场景提取建议
  - 推荐模型（基于共识）
  - 推荐参数（基于经验）
  - 适用/避免场景（基于反馈）
  ↓
步骤 4：验证建议
  - 是否有证据支持？
  - 是否有冲突观点？
  - 是否标注了来源？
  ↓
输出：scenarios = [{场景1}, {场景2}, ...]
```

---

## 示例

### 输入：文献综述技能的搜索结果

```
高频场景：
1. "我用 Opus 处理 100 篇论文，效果很好"（Reddit）
2. "Sonnet 够用，Opus 太贵"（HN）
3. "GPT-4o 在处理图表时更好"（社区）
4. "快速摘要用 Haiku 就够了"（官方文档）

冲突观点：
- 官方推荐 Opus，但社区更倾向 Sonnet（性价比）

数据支持：
- 某用户测试：Opus 准确率 87%，Sonnet 82%，但 Opus 贵 3 倍
```

### AI 自主生成的场景

```markdown
### 场景 1：超长文献综述（>50 篇论文）

- **触发条件**：需要处理大量文献，预算充足，质量优先
- **推荐模型**：Claude Opus 4.5
- **推荐参数**：
  - 推理强度：high
  - Thinking 模式：开
- **适用理由**：社区反馈一致认为 Opus 在超长文本中保持连贯性
- **避免场景**：成本敏感、快速迭代
- **来源依据**：Reddit 15+ 用户反馈
- **成本估算**：~$15-30/综述（基于 100 篇论文）

### 场景 2：标准文献调研（10-50 篇论文）

- **触发条件**：中等规模综述，平衡成本与质量
- **推荐模型**：Claude Sonnet 4.5
- **推荐参数**：
  - 推理强度：medium
  - Thinking 模式：可选
- **适用理由**：社区普遍认为 Sonnet 性价比高，多数场景够用
- **避免场景**：极端复杂的推理、超长文本
- **来源依据**：HN 讨论 + Reddit 共识
- **成本估算**：~$3-8/综述

### 场景 3：快速文献摘要（<10 篇论文）

- **触发条件**：快速了解领域，不需要深入分析
- **推荐模型**：Claude Haiku 4.5 或 GPT-4o
- **推荐参数**：
  - 推理强度：low
  - Thinking 模式：关
- **适用理由**：快速响应，成本最低
- **避免场景**：需要深入分析、复杂推理
- **来源依据**：官方文档 + 社区反馈
- **成本估算**：~$0.5-2/综述

### 场景 4：多模态文献（包含图表/图像）

- **触发条件**：文献包含图表、需要理解视觉内容
- **推荐模型**：GPT-4o
- **推荐参数**：
  - 推理强度：medium
  - Thinking 模式：关
- **适用理由**：多模态支持最好，社区推荐
- **避免场景**：纯文本超长任务（上下文限制）
- **来源依据**：社区对比讨论
- **成本估算**：~$5-10/综述
```

---

## 冲突处理

### 存在冲突时

```markdown
### ⚠️ 争议点：文献综述应该用 Opus 还是 Sonnet？

| 观点 | 支持者 | 理由 |
|------|-------|------|
| Opus | Anthropic 官方文档 | 最强推理能力，长文本连贯性最好 |
| Sonnet | Reddit/社区 | 性价比更高，90% 场景够用 |

**建议**：
- 预算充足 → Opus
- 成本敏感 → 先试 Sonnet，不够再升级

**数据支持**：
- 某用户测试：Opus 87% 准确率 vs Sonnet 82%
- 成本差异：Opus 是 Sonnet 的 3-5 倍
```

---

## 检查清单

- [ ] 每个场景是否有明确的触发条件？
- [ ] 是否有 3-5 个场景（太少则合并，太多则精简）？
- [ ] 是否每个场景都有来源依据？
- [ ] 是否标注了适用和避免场景？
- [ ] 是否展示了冲突观点？

---

## 你需要自主判断的内容

1. **场景数量**：根据搜索结果丰富度调整（3-8 个）
2. **场景边界**：确保场景独立，不重叠
3. **模型选择**：基于证据，不偏向任何厂商
4. **参数建议**：基于社区经验，而非猜测
5. **冲突处理**：并列展示，不偏向任何一方

---

## 与硬编码评分的配合

你的场景分析与 `scripts/score_sources.py` 的硬编码评分形成互补：

| 阶段 | 你的角色（自主规划） | 硬编码角色（稳定性） |
|------|---------------------|-------------------|
| 结果评分 | ❌ 不参与 | ✅ 硬编码公式评分 |
| 场景识别 | ✅ 自主识别和分类场景 | ❌ 不参与 |
| 冲突处理 | ✅ 自主判断和展示冲突 | ❌ 不参与 |
| 参数建议 | ✅ 自主基于经验建议 | ❌ 不参与 |

记住：**场景分析没有标准答案，基于证据灵活调整**。

# 检索策略指南

## 你的任务

根据目标技能的任务特征，**自主生成**高质量的检索词，避免回音室效应和营销陷阱。

---

## 核心原则

### 1. 多元化原则

**必须包含的检索词类型**：
- ✅ 任务特定："{model} for {task_type}"
- ✅ 社区反馈："{model} reddit experience"
- ✅ 缺点查询："{model} problems limitations"
- ✅ 对比查询："{model1} vs {model2}"

**避免的检索词类型**（营销陷阱）：
- ❌ "best practices"（营销内容太多）
- ❌ "official guide"（官方文档单独处理）
- ❌ "how to use"（低质量内容）

### 2. 厂商覆盖原则

即使目标厂商列表只有 1-2 个，也应该：
- 主动搜索"为什么不用其他厂商"
- 包含对比查询（vs 其他主流厂商）
- 理解用户为什么选择/不选择某个厂商

**目的**：避免回音室效应

### 3. 社区优先原则

**社区平台优先级**：
1. Reddit（r/LocalLLama, r/MachineLearning）
2. Hacker News
3. GitHub Issues
4. Stack Overflow

**检索词模板**：
```
"{model} reddit experience"
"{model} hacker news discussion"
"{model} github issues"
"{model} real world usage"
```

### 4. 缺点透明原则

**必须包含的缺点查询**：
```
"{model} disadvantages"
"{model} limitations"
"{model} problems"
"{model} not good for"
"why not {model}"
"{model} fails at"
```

---

## 自主规划流程

```
输入：task_features = {task_types: [...], complexity: "..."}
  ↓
步骤 1：分析任务特征
  - 主要任务类型是什么？
  - 复杂度如何？
  - 有什么特殊需求？
  ↓
步骤 2：为每个任务类型生成检索词
  - 任务特定查询（每个任务 2-3 个）
  - 社区反馈查询（每个任务 2 个）
  - 缺点查询（每个任务 1-2 个）
  ↓
步骤 3：生成对比查询
  - 如果单厂商：vs 主流对手
  - 如果多厂商：两两对比（最多 3 组）
  ↓
步骤 4：检查多样性
  - 是否包含社区查询？
  - 是否包含缺点查询？
  - 是否包含对比查询？
  ↓
输出：queries = [...]
```

---

## 示例

### 输入：文献综述技能
```
task_features = {
  task_types: ["文本生成", "数据处理", "联网搜索"],
  complexity: "high"
}
target_vendors = ["Anthropic", "OpenAI"]
```

### AI 自主生成的检索词
```python
queries = [
    # 文本生成 - 任务特定
    "Claude long text generation",
    "Opus literature review",
    "GPT-4 long text generation",
    "GPT-4o academic writing",

    # 文本生成 - 社区反馈
    "Claude long text reddit",
    "GPT-4 literature review experience",

    # 文本生成 - 缺点查询
    "Claude long text limitations",
    "GPT-4 coherence issues",

    # 数据处理 - 任务特定
    "Claude JSON processing",
    "GPT-4 structured output",

    # 数据处理 - 社区反馈
    "Claude data extraction reddit",

    # 联网搜索 - 任务特定
    "Claude web search",
    "GPT-4 browsing",

    # 对比查询
    "Claude vs GPT-4 literature review",
    "Opus vs GPT-4o long text",

    # 通用原则
    "LLM model selection academic writing"
]
```

---

## 检查清单

生成检索词后，检查：
- [ ] 是否包含社区反馈查询？
- [ ] 是否包含缺点查询？
- [ ] 是否包含对比查询？
- [ ] 是否避免了"best practices"等营销陷阱？
- [ ] 检索词数量是否在 15-30 之间（过多则精简）？

---

## 你需要自主判断的内容

1. **检索词数量**：根据任务复杂度调整（复杂任务多查询，简单任务少查询）
2. **检索词具体度**：根据任务类型调整（技术任务用术语，通用任务用描述）
3. **对比组合**：选择最有意义的对比（不一定要两两对比）
4. **是否需要跨语言**：某些国产模型可能需要中文检索词

---

## 与硬编码评分的配合

你的检索策略与 `scripts/score_sources.py` 的硬编码评分形成互补：

| 阶段 | 你的角色（自主规划） | 硬编码角色（稳定性） |
|------|---------------------|-------------------|
| 检索词生成 | ✅ 自主生成多样化检索词 | ❌ 不参与 |
| 搜索结果收集 | ✅ 收集所有相关结果 | ❌ 不参与 |
| **结果评分** | ❌ 不参与 | ✅ 硬编码公式评分 |
| 场景分析 | ✅ 自主识别和分类场景 | ❌ 不参与 |

记住：**检索策略没有标准答案，根据具体情况灵活调整**。

## WHICHMODEL - 模型选择最佳实践

本节由 `which-model` skill 自动调研生成，最后更新：{timestamp}

> **说明**：本节基于 {生成日期} 的调研结果。模型性能和最佳实践可能随时间变化，建议定期更新。

### 场景一：{场景名称}

**典型使用场景**：{场景描述（1-2 句）}

- **推荐模型**：{Claude Opus 4.5 / Claude Sonnet 4.5 / Claude Haiku 4.5}
- **推荐参数**：
  - 推理强度：{high / medium / low}
  - Thinking 模式：{开 / 关}
  - Temperature：{默认值}
  - Max Tokens：{建议值}
- **理由**：{简洁的理由（1-2 句）}
- **来源**：{来源名称与链接}

---

### 场景二：{场景名称}

**典型使用场景**：{场景描述（1-2 句）}

- **推荐模型**：{模型名称}
- **推荐参数**：
  - 推理强度：{强度}
  - Thinking 模式：{开/关}
  - 其他参数：{参数值}
- **理由**：{理由}
- **来源**：{来源}

---

### 通用原则

基于 {调研来源数量} 个来源的分析，总结以下通用原则：

1. **{原则标题}**
   - {原则说明}

2. **{原则标题}**
   - {原则说明}

3. **{原则标题}**
   - {原则说明}

### 更新记录

- {YYYY-MM-DD}：初始生成，基于 {X} 个来源的调研
- {YYYY-MM-DD}：{更新内容（如有）}

---

> 本节由 `which-model` skill 自动生成。如需更新，请运行：
> ```
> 请用 which-model 调研 {技能名称} 的模型选择最佳实践
> ```

#!/usr/bin/env python3
"""
analyze_skill.py - 占位符脚本

⚠️  注意：本脚本已移除所有硬编码规则。
    实际分析由 AI (Claude) 完成，基于语义理解。

本脚本仅用于：
1. 验证技能目录存在
2. 创建占位符文件结构
3. 为 AI 分析提供文件位置
"""

import json
from datetime import datetime
from pathlib import Path
from typing import Dict, Any


def create_placeholder(skill_dir: Path) -> Dict[str, Any]:
    """创建占位符分析，等待 AI 填充"""

    # 读取 SKILL.md 前 500 字符，用于 AI 快速了解
    skill_md_path = skill_dir / 'SKILL.md'
    preview = ""
    if skill_md_path.exists():
        with open(skill_md_path, 'r', encoding='utf-8') as f:
            preview = f.read(500)

    return {
        '_meta': {
            'version': '2.0',  # AI-first 版本
            'analyzed_by': 'AI (Claude)',
            'analyzed_at': None,  # AI 填充
            'skill_path': str(skill_dir),
            'skill_preview': preview  # 预览，帮助 AI 快速了解
        },

        # 以下字段由 AI 填充
        'task_features': {
            'task_types': [],  # AI 填充：基于语义理解
            'context_requirements': None,  # AI 填充：short/medium/long
            'output_requirements': [],  # AI 填充：markdown/latex/pdf/json
            'complexity_level': None,  # AI 填充：low/medium/high
            'performance_priority': None,  # AI 填充：速度/质量/平衡
            'workflow_summary': None  # AI 填充：工作流语义理解
        },

        'model_recommendations': {
            'primary': None,  # AI 填充：推荐的主模型
            'primary_reasoning': None,  # AI 填充：推荐理由
            'alternatives': []  # AI 填充：备选模型及使用场景
        },

        # AI 分析过程（可追溯）
        '_reasoning': {
            'task_understanding': None,  # AI 如何理解技能
            'complexity_rationale': None,  # AI 如何判断复杂度
            'model_selection_rationale': None  # AI 如何选择模型
        }
    }


def analyze_skill(skill_dir: Path) -> Dict[str, Any]:
    """
    分析技能（占位符）

    注意：实际分析由 AI 完成。
    本函数仅创建占位符结构。
    """
    if not skill_dir.exists():
        raise FileNotFoundError(f"技能目录不存在: {skill_dir}")

    skill_md_path = skill_dir / 'SKILL.md'
    if not skill_md_path.exists():
        raise FileNotFoundError(f"SKILL.md 不存在: {skill_md_path}")

    return create_placeholder(skill_dir)


def main():
    import sys

    if len(sys.argv) < 2:
        print("Usage: python analyze_skill.py <skill_dir>")
        print("\n注意：本脚本仅创建占位符，实际分析由 AI 完成。")
        sys.exit(1)

    skill_dir = Path(sys.argv[1])

    try:
        analysis = analyze_skill(skill_dir)
        output_path = skill_dir / 'skill_analysis.json'

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

        print(f"✓ 占位符已创建: {output_path}")
        print(f"✓ 技能目录: {skill_dir}")
        print(f"\n等待 AI 分析并填充...")
        print(f"AI 将分析：{skill_dir / 'SKILL.md'}")

    except FileNotFoundError as e:
        print(f"✗ 错误: {e}")
        sys.exit(1)
    except Exception as e:
        print(f"✗ 意外错误: {e}")
        import traceback
        traceback.print_exc()
        sys.exit(1)


if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""
generate_whichmodel.py - 生成 WHICHMODEL 小节

功能：
1. 从调研结果中提取结构化知识
2. 按 WHICHMODEL 模板组织内容
3. 生成 Markdown 格式的最佳实践小节
"""

import json
import os
import re
import sys
from datetime import datetime
from pathlib import Path
from typing import Dict, List, Any


def extract_knowledge(research_results: Dict[str, Any], skill_analysis: Dict[str, Any]) -> Dict[str, Any]:
    """从搜索结果中提取结构化知识"""
    results = research_results.get('results', [])

    # 初始化知识结构
    knowledge = {
        'scenarios': [],
        'general_principles': [],
        'model_patterns': {
            'Opus': {'use_cases': [], 'typical_params': {}},
            'Sonnet': {'use_cases': [], 'typical_params': {}},
            'Haiku': {'use_cases': [], 'typical_params': {}}
        }
    }

    # 分析每个搜索结果
    for result in results:
        title = result.get('title', '')
        snippet = result.get('snippet', '')
        url = result.get('url', '')
        text = f"{title} {snippet}".lower()

        # 识别模型使用场景
        if 'opus' in text and ('complex' in text or 'long' in text or 'quality' in text):
            knowledge['model_patterns']['Opus']['use_cases'].append({
                'scenario': title,
                'reason': snippet[:100],
                'source': url
            })

        if 'sonnet' in text and ('balanced' in text or 'code' in text):
            knowledge['model_patterns']['Sonnet']['use_cases'].append({
                'scenario': title,
                'reason': snippet[:100],
                'source': url
            })

        if 'haiku' in text and ('fast' in text or 'quick' in text or 'simple' in text):
            knowledge['model_patterns']['Haiku']['use_cases'].append({
                'scenario': title,
                'reason': snippet[:100],
                'source': url
            })

        # 识别通用原则
        if any(word in text for word in ['principle', 'best practice', 'guideline', 'recommend']):
            knowledge['general_principles'].append({
                'title': title,
                'content': snippet[:200],
                'source': url
            })

    return knowledge


def generate_scenarios(knowledge: Dict[str, Any], skill_analysis: Dict[str, Any]) -> List[Dict[str, Any]]:
    """基于知识和技能分析生成场景"""
    task_types = skill_analysis.get('task_features', {}).get('task_types', [])
    complexity = skill_analysis.get('task_features', {}).get('complexity_level', 'medium')

    scenarios = []

    # 基于任务类型生成场景
    scenario_map = {
        '文本生成': {
            'name': '长文本生成（综述/报告）',
            'model': 'Claude Opus 4.5',
            'reasoning': 'high',
            'thinking': True,
            'reason': '需要强推理能力确保内容连贯性和深度'
        },
        '代码分析': {
            'name': '代码分析与重构',
            'model': 'Claude Sonnet 4.5',
            'reasoning': 'medium',
            'thinking': False,
            'reason': '结构化思维适合代码分析，性价比高'
        },
        '联网搜索': {
            'name': '信息检索与综合',
            'model': 'Claude Sonnet 4.5',
            'reasoning': 'medium',
            'thinking': True,
            'reason': '需要综合多源信息但无需最强推理'
        },
        '数据处理': {
            'name': '数据提取与处理',
            'model': 'Claude Haiku 4.5',
            'reasoning': 'low',
            'thinking': False,
            'reason': '结构化任务，快速响应优先'
        }
    }

    for task_type in task_types:
        if task_type in scenario_map:
            scenarios.append(scenario_map[task_type])

    # 如果没有匹配场景，添加默认场景
    if not scenarios:
        scenarios.append({
            'name': '标准任务执行',
            'model': 'Claude Sonnet 4.5',
            'reasoning': 'medium',
            'thinking': False,
            'reason': '平衡性能与成本，适用于大多数任务'
        })

    return scenarios


def load_template(template_path: Path) -> str:
    """加载 WHICHMODEL 模板"""
    if not template_path.exists():
        # 返回默认模板
        return """## WHICHMODEL - 模型选择最佳实践

本节由 `which-model` skill 自动调研生成，最后更新：{timestamp}

{scenarios}

### 通用原则

{principles}

### 更新记录

- {timestamp}：初始生成
"""

    with open(template_path, 'r', encoding='utf-8') as f:
        return f.read()


def format_scenario(scenario: Dict[str, Any], index: int) -> str:
    """格式化单个场景"""
    return f"""### 场景{index}：{scenario['name']}

**典型使用场景**：基于技能任务特征分析得出

- **推荐模型**：{scenario['model']}
- **推荐参数**：
  - 推理强度：{scenario['reasoning']}
  - Thinking 模式：{'开' if scenario.get('thinking', False) else '关'}
  - Temperature：{scenario.get('temperature', '默认值')}
  - Max Tokens：{scenario.get('max_tokens', '按需设置')}
- **理由**：{scenario['reason']}
- **来源**：基于 {len(scenario.get('sources', []))} 个来源的调研分析

---"""


def generate_whichmodel_section(
    knowledge: Dict[str, Any],
    skill_analysis: Dict[str, Any],
    template_path: Path = None
) -> str:
    """生成 WHICHMODEL 小节"""
    timestamp = datetime.now().strftime('%Y-%m-%d')

    # 加载模板
    if template_path is None:
        template_path = Path(__file__).resolve().parents[1] / 'references' / 'WHICHMODEL_template.md'

    template = load_template(template_path)

    # 生成场景
    scenarios = generate_scenarios(knowledge, skill_analysis)
    scenarios_text = '\n\n'.join([
        format_scenario(s, i + 1)
        for i, s in enumerate(scenarios[:8])  # 最多 8 个场景
    ])

    # 生成通用原则
    principles = knowledge.get('general_principles', [])
    if not principles:
        # 默认原则
        principles_text = """1. **复杂度与模型匹配**
   - 高复杂度任务（多步骤推理、长文本生成）→ Claude Opus 4.5
   - 中等复杂度任务（代码分析、标准写作）→ Claude Sonnet 4.5
   - 简单任务（数据处理、快速响应）→ Claude Haiku 4.5

2. **成本效益平衡**
   - 优先尝试 Sonnet，在质量不足时升级到 Opus
   - 批量任务考虑使用 Haiku 降低成本

3. **参数调优**
   - 推理强度：质量优先用 high，速度优先用 low
   - Thinking 模式：复杂推理任务建议开启
   - Temperature：创造性任务可适当提高"""
    else:
        principles_text = '\n\n'.join([
            f"{i+1}. **{p.get('title', '原则')}**\n   {p.get('content', '')[:200]}"
            for i, p in enumerate(principles[:5])
        ])

    # 填充模板
    content = template.format(
        timestamp=timestamp,
        scenarios=scenarios_text,
        principles=principles_text,
       生成日期=timestamp,
        调研来源数量=len(principles),
        X=len(principles),
        YYYY_MM_DD=timestamp
    )

    return content


def main():
    if len(sys.argv) < 3:
        print("Usage: python generate_whichmodel.py <research_results.json> <skill_analysis.json>")
        sys.exit(1)

    research_path = Path(sys.argv[1])
    analysis_path = Path(sys.argv[2])

    if not research_path.exists() or not analysis_path.exists():
        print("Error: Input files not found")
        sys.exit(1)

    try:
        with open(research_path, 'r', encoding='utf-8') as f:
            research_results = json.load(f)

        with open(analysis_path, 'r', encoding='utf-8') as f:
            skill_analysis = json.load(f)

        # 提取知识
        knowledge = extract_knowledge(research_results, skill_analysis)

        # 生成 WHICHMODEL 小节
        whichmodel_section = generate_whichmodel_section(
            knowledge,
            skill_analysis
        )

        # 保存到文件
        skill_dir = Path(analysis_path).parent
        output_path = skill_dir / 'WHICHMODEL_section.md'

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

        print(f"WHICHMODEL section generated: {output_path}")
        print(f"Section length: {len(whichmodel_section)} characters")

    except Exception as e:
        print(f"Error during generation: {e}")
        import traceback
        traceback.print_exc()
        sys.exit(1)


if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""
research_models.py - 通过联网搜索调研模型最佳实践

功能：
1. 基于任务特征生成检索词
2. 使用 MCP 工具执行搜索
3. 收集并评分搜索结果
4. 输出 research_results.json
"""

import json
import os
import sys
from datetime import datetime
from pathlib import Path
from typing import Dict, List, Any


# MCP 工具优先级（通过环境变量或直接调用）
MCP_SEARCH_PRIORITY = [
    'tavily-search',
    'searxng_web_search',
    'search'  # DuckDuckGo
]


def generate_search_queries(task_features: Dict[str, Any], target_vendors: List[str] = None) -> List[str]:
    """基于任务特征生成检索词

    Args:
        task_features: 技能任务特征分析结果
        target_vendors: 目标模型厂商列表，默认为 ['Anthropic', 'OpenAI']
    """
    if target_vendors is None:
        target_vendors = ['Anthropic', 'OpenAI']

    queries = []

    task_types = task_features.get('task_types', [])
    complexity = task_features.get('complexity_level', 'medium')

    # 厂商特定模型名称映射
    vendor_models = {
        'Anthropic': ['Claude', 'Opus', 'Sonnet', 'Haiku'],
        'OpenAI': ['GPT-4', 'GPT-4o', 'o1', 'GPT'],
        'Google': ['Gemini', 'Gemini Pro', 'Gemini Ultra'],
        'Meta': ['Llama', 'Llama 2', 'Llama 3'],
        'Mistral': ['Mistral', 'Mixtral', 'Mistral Large'],
        'DeepSeek': ['DeepSeek', 'DeepSeek-V2', 'DeepSeek-Coder']
    }

    # 为每个厂商收集模型名称（每个厂商最多 2 个，避免查询过多）
    vendor_model_names = {}
    for vendor in target_vendors:
        if vendor in vendor_models:
            vendor_model_names[vendor] = vendor_models[vendor][:2]

    # 基础查询词模板（支持多厂商）
    query_templates = {
        '文本生成': [
            '{model} long text generation',
            '{model} writing best practice',
            '{model} content generation'
        ],
        '代码分析': [
            '{model} code analysis',
            '{model} code review',
            '{model} code understanding'
        ],
        '联网搜索': [
            '{model} web search',
            '{model} information retrieval'
        ],
        '数据处理': [
            '{model} data extraction',
            '{model} JSON processing',
            '{model} structured output'
        ],
        '多步骤推理': [
            '{model} complex reasoning',
            '{model} chain of thought',
            '{model} problem solving'
        ]
    }

    # 为每个任务类型和厂商组合生成查询
    for task_type in task_types:
        if task_type in query_templates:
            for template in query_templates[task_type]:
                for vendor in target_vendors:
                    if vendor in vendor_model_names:
                        for model_name in vendor_model_names[vendor]:
                            queries.append(template.format(model=model_name))

    # 添加模型对比查询（跨厂商）
    if len(target_vendors) > 1:
        vendor_pairs = []
        for i, vendor1 in enumerate(target_vendors):
            for vendor2 in target_vendors[i+1:]:
                vendor_pairs.append((vendor1, vendor2))

        for vendor1, vendor2 in vendor_pairs[:2]:  # 最多 2 组对比
            model1 = vendor_models.get(vendor1, [vendor1])[0]
            model2 = vendor_models.get(vendor2, [vendor2])[0]
            queries.append(f'{model1} vs {model2} comparison')
            queries.append(f'{model1} or {model2} which is better')

    # 添加通用参数查询（不特定于厂商）
    queries.extend([
        'LLM reasoning intensity best practice',
        'LLM temperature parameters guide',
        'when to use different LLM models'
    ])

    return list(set(queries))  # 去重


def search_with_mcp(query: str, max_results: int = 10) -> List[Dict[str, Any]]:
    """使用 MCP 工具执行搜索"""
    results = []

    # 尝试按优先级使用 MCP 工具
    for tool_name in MCP_SEARCH_PRIORITY:
        try:
            # 这里需要实际的 MCP 工具调用
            # 以下是模拟实现，实际使用时需要集成真实的 MCP 工具
            print(f"Searching with {tool_name}: {query}")

            # 模拟搜索结果
            mock_results = [
                {
                    'title': f"Mock result for: {query}",
                    'url': f"https://example.com/{query.replace(' ', '-')}",
                    'snippet': f"Mock search result snippet about {query}",
                    'source': tool_name
                }
            ]

            results.extend(mock_results)
            break  # 成功后不再尝试其他工具

        except Exception as e:
            print(f"Failed to use {tool_name}: {e}")
            continue

    return results


def score_relevance(result: Dict[str, Any], query: str) -> float:
    """评分搜索结果的相关性（0-1）"""
    title = result.get('title', '').lower()
    snippet = result.get('snippet', '').lower()
    query_lower = query.lower()

    # 简单的关键词匹配评分
    score = 0.0

    query_words = set(query_lower.split())
    title_words = set(title.split())
    snippet_words = set(snippet.split())

    # 标题匹配权重更高
    title_match = len(query_words & title_words) / max(len(query_words), 1)
    snippet_match = len(query_words & snippet_words) / max(len(query_words), 1)

    score = title_match * 0.7 + snippet_match * 0.3

    return min(score, 1.0)


def research_models(skill_analysis: Dict[str, Any], config: Dict[str, Any] = None) -> Dict[str, Any]:
    """执行完整的模型调研流程"""
    if config is None:
        config = {}

    task_features = skill_analysis.get('task_features', {})
    max_results = config.get('research', {}).get('max_results_per_query', 10)
    relevance_threshold = config.get('research', {}).get('relevance_threshold', 0.6)
    target_vendors = config.get('research', {}).get('target_vendors', ['Anthropic', 'OpenAI'])

    # 1. 生成检索词（传入目标厂商）
    queries = generate_search_queries(task_features, target_vendors)

    # 2. 执行搜索
    all_results = []
    for query in queries:
        results = search_with_mcp(query, max_results)
        for result in results:
            result['query'] = query
            result['relevance_score'] = score_relevance(result, query)
        all_results.extend(results)

    # 3. 过滤低相关性结果
    filtered_results = [
        r for r in all_results
        if r['relevance_score'] >= relevance_threshold
    ]

    # 4. 排序
    filtered_results.sort(key=lambda x: x['relevance_score'], reverse=True)

    return {
        'timestamp': datetime.now().isoformat(),
        'skill_name': skill_analysis.get('skill_name'),
        'queries_used': queries,
        'total_results': len(all_results),
        'filtered_results': len(filtered_results),
        'results': filtered_results[:50]  # 限制返回数量
    }


def load_config(config_path: Path = None) -> Dict[str, Any]:
    """加载配置文件"""
    if config_path is None:
        # 默认使用 which-model 技能目录下的 config.yaml
        script_dir = Path(__file__).resolve().parents[1]
        config_path = script_dir / 'config.yaml'

    if not config_path.exists():
        return {}

    try:
        import yaml
        with open(config_path, 'r', encoding='utf-8') as f:
            return yaml.safe_load(f) or {}
    except ImportError:
        print("Warning: PyYAML not installed, using default config")
        return {}
    except Exception as e:
        print(f"Warning: Failed to load config from {config_path}: {e}")
        return {}


def main():
    if len(sys.argv) < 2:
        print("Usage: python research_models.py <skill_analysis.json> [config_path]")
        sys.exit(1)

    analysis_path = Path(sys.argv[1])
    config_path = Path(sys.argv[2]) if len(sys.argv) > 2 else None

    if not analysis_path.exists():
        print(f"Error: Analysis file not found: {analysis_path}")
        sys.exit(1)

    try:
        # 加载配置
        config = load_config(config_path)

        with open(analysis_path, 'r', encoding='utf-8') as f:
            skill_analysis = json.load(f)

        # 显示使用的配置
        target_vendors = config.get('research', {}).get('target_vendors', ['Anthropic', 'OpenAI'])
        print(f"Target vendors: {', '.join(target_vendors)}")

        research_results = research_models(skill_analysis, config)

        # 保存到技能目录
        skill_dir = Path(analysis_path).parent
        output_path = skill_dir / 'research_results.json'

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

        print(f"Research complete. Results saved to: {output_path}")
        print(f"Found {research_results['filtered_results']} relevant results")
        print(f"Queries used: {len(research_results['queries_used'])}")

    except Exception as e:
        print(f"Error during research: {e}")
        import traceback
        traceback.print_exc()
        sys.exit(1)


if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""
score_sources.py - 硬编码的来源评分逻辑

功能：
1. 从 config.yaml 加载来源可信度配置
2. 计算每个搜索结果的综合得分
3. 应用营销倾向惩罚
4. 输出评分后的结果

设计原则：硬编码确保评分稳定性，不受 AI 自主规划影响
"""

import json
import re
from pathlib import Path
from typing import Dict, List, Any
from urllib.parse import urlparse


def load_config(config_path: Path = None) -> Dict[str, Any]:
    """加载配置文件"""
    if config_path is None:
        config_path = Path(__file__).resolve().parents[1] / 'config.yaml'

    if not config_path.exists():
        return {}

    try:
        import yaml
        with open(config_path, 'r', encoding='utf-8') as f:
            return yaml.safe_load(f) or {}
    except Exception as e:
        print(f"Warning: Failed to load config: {e}")
        return {}


def get_domain_credibility_weight(url: str, config: Dict[str, Any]) -> float:
    """获取域名可信度权重（硬编码）"""
    try:
        domain = urlparse(url).netloc.lower()
    except Exception:
        return 0.5

    # 移除 www. 前缀
    if domain.startswith('www.'):
        domain = domain[4:]

    credibility_config = config.get('source_credibility', {})
    domain_weights = credibility_config.get('domain_weights', {})

    # 检查每个类别
    for category, data in domain_weights.items():
        if isinstance(data, dict) and 'domains' in data:
            if domain in data['domains']:
                return data.get('weight', 0.5)

    # 未知域名返回默认权重
    return credibility_config.get('unknown_domain_weight', 0.5)


def detect_marketing_bias(text: str, config: Dict[str, Any]) -> float:
    """检测营销倾向（硬编码）"""
    bias_config = config.get('bias_detection', {})

    # 获取关键词列表
    marketing_words = bias_config.get('marketing_words', {})
    positive_excess = marketing_words.get('positive_excess', [])
    absolute_words = marketing_words.get('absolute_words', [])
    balanced_indicators = bias_config.get('balanced_indicators', [])

    # 获取阈值
    marketing_threshold = bias_config.get('sentiment_thresholds', {}).get('marketing_too_positive', 3)
    absolute_threshold = bias_config.get('sentiment_thresholds', {}).get('absolute_excess', 2)

    text_lower = text.lower()

    # 统计过度正面词汇
    positive_count = sum(1 for word in positive_excess if word in text_lower)

    # 统计绝对化词语
    absolute_count = sum(1 for word in absolute_words if word in text_lower)

    # 统计平衡指标
    balanced_count = sum(1 for word in balanced_indicators if word in text_lower)

    # 计算营销倾向分数（0-1，越低表示营销倾向越强）
    marketing_score = 1.0

    # 过度正面惩罚
    if positive_count >= marketing_threshold and balanced_count == 0:
        marketing_score -= 0.4  # 严重营销倾向

    # 绝对化词语惩罚
    if absolute_count >= absolute_threshold and balanced_count == 0:
        marketing_score -= 0.3

    # 有平衡指标，奖励
    if balanced_count >= 2:
        marketing_score = min(marketing_score + 0.1, 1.0)

    return max(marketing_score, 0.0)


def calculate_impartial_score(
    result: Dict[str, Any],
    query: str,
    config: Dict[str, Any]
) -> float:
    """计算综合客观性评分（硬编码公式）"""
    scoring_config = config.get('scoring', {})

    # 获取权重
    formula = scoring_config.get('formula', {})
    relevance_weight = formula.get('relevance_weight', 0.30)
    credibility_weight = formula.get('credibility_weight', 0.50)
    neutrality_weight = formula.get('neutrality_weight', 0.20)

    # 1. 相关性评分（来自 research_models.py）
    relevance = result.get('relevance_score', 0.5)

    # 2. 可信度评分（基于域名）
    credibility = get_domain_credibility_weight(result.get('url', ''), config)

    # 3. 中立性评分（检测营销倾向）
    title_snippet = result.get('title', '') + ' ' + result.get('snippet', '')
    neutrality = detect_marketing_bias(title_snippet, config)

    # 综合评分（硬编码公式）
    final_score = (
        relevance * relevance_weight +
        credibility * credibility_weight +
        neutrality * neutrality_weight
    )

    return final_score


def score_research_results(
    research_results: Dict[str, Any],
    config: Dict[str, Any] = None
) -> Dict[str, Any]:
    """对所有调研结果进行评分"""
    if config is None:
        config = load_config()

    results = research_results.get('results', [])

    # 为每个结果计算综合评分
    for result in results:
        query = result.get('query', '')
        result['impartial_score'] = calculate_impartial_score(result, query, config)

        # 添加评分详情（用于调试）
        title_snippet = result.get('title', '') + ' ' + result.get('snippet', '')
        result['score_details'] = {
            'relevance': result.get('relevance_score', 0.5),
            'credibility': get_domain_credibility_weight(result.get('url', ''), config),
            'neutrality': detect_marketing_bias(title_snippet, config)
        }

    # 按综合评分重新排序
    results.sort(key=lambda x: x['impartial_score'], reverse=True)

    # 过滤低分结果
    min_score = config.get('scoring', {}).get('min_acceptable_score', 0.4)
    filtered_results = [r for r in results if r['impartial_score'] >= min_score]

    return {
        'timestamp': research_results.get('timestamp'),
        'skill_name': research_results.get('skill_name'),
        'queries_used': research_results.get('queries_used'),
        'total_results': len(results),
        'filtered_results': len(filtered_results),
        'results': filtered_results[:50],  # 限制返回数量
        'scoring_method': 'hardcoded_formula_v1'  # 标记使用硬编码
    }


def main():
    import sys

    if len(sys.argv) < 2:
        print("Usage: python score_sources.py <research_results.json> [config_path]")
        sys.exit(1)

    research_path = Path(sys.argv[1])
    config_path = Path(sys.argv[2]) if len(sys.argv) > 2 else None

    if not research_path.exists():
        print(f"Error: Research results file not found: {research_path}")
        sys.exit(1)

    try:
        # 加载配置
        config = load_config(config_path)

        # 加载调研结果
        with open(research_path, 'r', encoding='utf-8') as f:
            research_results = json.load(f)

        # 评分
        scored_results = score_research_results(research_results, config)

        # 保存
        output_path = research_path.parent / 'research_results_scored.json'
        with open(output_path, 'w', encoding='utf-8') as f:
            json.dump(scored_results, f, indent=2, ensure_ascii=False)

        print(f"✅ Scoring complete. Results saved to: {output_path}")
        print(f"📊 Filtered results: {scored_results['filtered_results']}/{scored_results['total_results']}")

        # 显示一些统计信息
        if scored_results['results']:
            avg_score = sum(r['impartial_score'] for r in scored_results['results']) / len(scored_results['results'])
            print(f"📈 Average impartial score: {avg_score:.2f}")

    except Exception as e:
        print(f"❌ Error during scoring: {e}")
        import traceback
        traceback.print_exc()
        sys.exit(1)


if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""
test_target_vendors.py - 测试 target_vendors 参数功能

验证：
1. 默认厂商列表为 ['Anthropic', 'OpenAI']
2. 可以从 config.yaml 读取 target_vendors
3. generate_search_queries 正确使用 target_vendors
"""

import json
import sys
from pathlib import Path

# 添加 scripts 目录到路径
scripts_dir = Path(__file__).resolve().parents[1] / 'scripts'
sys.path.insert(0, str(scripts_dir))

from research_models import generate_search_queries, load_config


def test_default_vendors():
    """测试默认厂商列表"""
    print("测试 1: 默认厂商列表")

    task_features = {
        'task_types': ['文本生成'],
        'complexity_level': 'medium'
    }

    queries = generate_search_queries(task_features)

    # 验证包含 Anthropic 和 OpenAI 的模型
    has_anthropic = any('Claude' in q or 'Opus' in q or 'Sonnet' in q for q in queries)
    has_openai = any('GPT' in q or 'GPT-4' in q for q in queries)

    assert has_anthropic, "应包含 Anthropic 模型名"
    assert has_openai, "应包含 OpenAI 模型名"

    print("✓ 默认厂商列表测试通过")
    print(f"  生成了 {len(queries)} 个查询")
    print(f"  示例查询: {queries[:3]}")
    return True


def test_custom_vendors():
    """测试自定义厂商列表"""
    print("\n测试 2: 自定义厂商列表")

    task_features = {
        'task_types': ['文本生成'],
        'complexity_level': 'medium'
    }

    # 仅 Anthropic
    queries_anthropic = generate_search_queries(task_features, ['Anthropic'])
    has_anthropic_only = any('Claude' in q or 'Opus' in q for q in queries_anthropic)
    has_no_openai = not any('GPT' in q for q in queries_anthropic)

    assert has_anthropic_only, "应包含 Anthropic 模型名"
    assert has_no_openai, "不应包含 OpenAI 模型名"

    print("✓ 仅 Anthropic 测试通过")
    print(f"  生成了 {len(queries_anthropic)} 个查询")

    # Anthropic + Google
    queries_mixed = generate_search_queries(task_features, ['Anthropic', 'Google'])
    has_google = any('Gemini' in q for q in queries_mixed)

    assert has_google, "应包含 Google 模型名"

    print("✓ Anthropic + Google 测试通过")
    print(f"  生成了 {len(queries_mixed)} 个查询")
    return True


def test_config_loading():
    """测试从 config.yaml 加载配置"""
    print("\n测试 3: 从 config.yaml 加载配置")

    config_path = Path(__file__).resolve().parents[1] / 'config.yaml'
    config = load_config(config_path)

    target_vendors = config.get('research', {}).get('target_vendors', [])

    assert len(target_vendors) > 0, "config.yaml 应定义 target_vendors"
    assert 'Anthropic' in target_vendors, "默认应包含 Anthropic"
    assert 'OpenAI' in target_vendors, "默认应包含 OpenAI"

    print("✓ config.yaml 加载测试通过")
    print(f"  配置的厂商: {', '.join(target_vendors)}")
    return True


def test_vendor_specific_models():
    """测试厂商特定模型名称映射"""
    print("\n测试 4: 厂商特定模型名称映射")

    task_features = {
        'task_types': ['文本生成'],
        'complexity_level': 'medium'
    }

    # 测试所有支持的厂商
    all_vendors = ['Anthropic', 'OpenAI', 'Google', 'Meta', 'Mistral', 'DeepSeek']

    queries = generate_search_queries(task_features, all_vendors)

    # 验证每个厂商的模型名都出现在查询中
    vendor_keywords = {
        'Anthropic': ['Claude', 'Opus'],
        'OpenAI': ['GPT'],
        'Google': ['Gemini'],
        'Meta': ['Llama'],
        'Mistral': ['Mistral'],
        'DeepSeek': ['DeepSeek']
    }

    for vendor, keywords in vendor_keywords.items():
        found = any(any(keyword in q for keyword in keywords) for q in queries)
        assert found, f"应包含 {vendor} 的模型名"
        print(f"  ✓ {vendor}: 已包含")

    print("✓ 厂商特定模型名称映射测试通过")
    return True


def test_cross_vendor_comparison():
    """测试跨厂商对比查询生成"""
    print("\n测试 5: 跨厂商对比查询生成")

    task_features = {
        'task_types': ['文本生成'],
        'complexity_level': 'medium'
    }

    # 多厂商应生成对比查询
    queries = generate_search_queries(task_features, ['Anthropic', 'OpenAI', 'Google'])

    has_comparison = any(
        'vs' in q or 'comparison' in q or 'which is better' in q
        for q in queries
    )

    assert has_comparison, "多厂商应生成对比查询"

    comparison_queries = [q for q in queries if 'vs' in q or 'comparison' in q]
    print(f"✓ 跨厂商对比查询测试通过")
    print(f"  对比查询数: {len(comparison_queries)}")
    print(f"  示例: {comparison_queries[:2]}")
    return True


def main():
    print("=" * 60)
    print("target_vendors 参数功能测试")
    print("=" * 60)

    tests = [
        test_default_vendors,
        test_custom_vendors,
        test_config_loading,
        test_vendor_specific_models,
        test_cross_vendor_comparison
    ]

    passed = 0
    failed = 0

    for test in tests:
        try:
            if test():
                passed += 1
        except AssertionError as e:
            failed += 1
            print(f"✗ 测试失败: {e}")
        except Exception as e:
            failed += 1
            print(f"✗ 测试错误: {e}")
            import traceback
            traceback.print_exc()

    print("\n" + "=" * 60)
    print(f"测试总结: {passed} 通过, {failed} 失败")
    print("=" * 60)

    return 0 if failed == 0 else 1


if __name__ == '__main__':
    sys.exit(main())

#!/bin/bash
# test_whichmodel.sh - which-model 技能的测试验证脚本

set -e  # 遇到错误立即退出

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

# 测试计数器
TESTS_TOTAL=0
TESTS_PASSED=0
TESTS_FAILED=0

# 日志函数
log_info() {
    echo -e "${GREEN}[INFO]${NC} $1"
}

log_warn() {
    echo -e "${YELLOW}[WARN]${NC} $1"
}

log_error() {
    echo -e "${RED}[ERROR]${NC} $1"
}

# 测试函数
run_test() {
    local test_name=$1
    local test_command=$2

    TESTS_TOTAL=$((TESTS_TOTAL + 1))
    echo ""
    echo "========================================="
    echo "测试 $TESTS_TOTAL: $test_name"
    echo "========================================="

    if eval "$test_command"; then
        TESTS_PASSED=$((TESTS_PASSED + 1))
        log_info "✓ 测试通过"
        return 0
    else
        TESTS_FAILED=$((TESTS_FAILED + 1))
        log_error "✗ 测试失败"
        return 1
    fi
}

# 获取脚本所在目录
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
SKILL_DIR="$(dirname "$SCRIPT_DIR")"
PROJECT_ROOT="$(dirname "$SKILL_DIR")"

echo "========================================="
echo "which-model 技能测试套件"
echo "========================================="
echo "技能目录: $SKILL_DIR"
echo "项目根目录: $PROJECT_ROOT"
echo ""

# ============================================
# 1. 静态结构测试
# ============================================
echo ""
echo "========================================="
echo "第一部分：静态结构测试"
echo "========================================="

run_test "SKILL.md 文件存在" "[ -f '$SKILL_DIR/SKILL.md' ]"

run_test "README.md 文件存在" "[ -f '$SKILL_DIR/README.md' ]"

run_test "config.yaml 文件存在" "[ -f '$SKILL_DIR/config.yaml' ]"

run_test "scripts/ 目录存在" "[ -d '$SKILL_DIR/scripts' ]"

run_test "references/ 目录存在" "[ -d '$SKILL_DIR/references' ]"

run_test "WHICHMODEL 模板存在" "[ -f '$SKILL_DIR/references/WHICHMODEL_template.md' ]"

# ============================================
# 2. 脚本可执行性测试
# ============================================
echo ""
echo "========================================="
echo "第二部分：脚本可执行性测试"
echo "========================================="

run_test "analyze_skill.py 存在" "[ -f '$SKILL_DIR/scripts/analyze_skill.py' ]"

run_test "research_models.py 存在" "[ -f '$SKILL_DIR/scripts/research_models.py' ]"

run_test "generate_whichmodel.py 存在" "[ -f '$SKILL_DIR/scripts/generate_whichmodel.py' ]"

# ============================================
# 3. YAML 语法测试
# ============================================
echo ""
echo "========================================="
echo "第三部分：YAML 语法测试"
echo "========================================="

run_test "config.yaml 语法正确" "python3 -c 'import yaml; yaml.safe_load(open(\"$SKILL_DIR/config.yaml\"))'"

run_test "SKILL.md frontmatter 语法正确" "python3 -c '
import yaml
import re
with open(\"$SKILL_DIR/SKILL.md\", \"r\") as f:
    content = f.read()
    match = re.search(r\"^---\$(.*?)^---\$\", content, re.DOTALL | re.MULTILINE)
    if match:
        yaml.safe_load(match.group(1))
    else:
        exit(1)
'"

# ============================================
# 4. Python 语法测试
# ============================================
echo ""
echo "========================================="
echo "第四部分：Python 语法测试"
echo "========================================="

run_test "analyze_skill.py 语法正确" "python3 -m py_compile '$SKILL_DIR/scripts/analyze_skill.py'"

run_test "research_models.py 语法正确" "python3 -m py_compile '$SKILL_DIR/scripts/research_models.py'"

run_test "generate_whichmodel.py 语法正确" "python3 -m py_compile '$SKILL_DIR/scripts/generate_whichmodel.py'"

# ============================================
# 5. 功能测试（使用示例技能）
# ============================================
echo ""
echo "========================================="
echo "第五部分：功能测试"
echo "========================================="

# 使用 systematic-literature-review 作为测试目标
TEST_SKILL="$PROJECT_ROOT/systematic-literature-review"

if [ -d "$TEST_SKILL" ]; then
    log_info "使用测试技能: $TEST_SKILL"

    # 创建临时测试目录
    TEST_TEMP_DIR=$(mktemp -d)
    log_info "临时测试目录: $TEST_TEMP_DIR"

    # 测试 1: 分析技能
    run_test "analyze_skill.py 执行成功" "python3 '$SKILL_DIR/scripts/analyze_skill.py' '$TEST_SKILL'"

    # 测试 2: 检查分析输出
    if [ -f "$TEST_SKILL/skill_analysis.json" ]; then
        run_test "skill_analysis.json 生成且有效" "python3 -c '
import json
import sys
with open(\"$TEST_SKILL/skill_analysis.json\", \"r\") as f:
    data = json.load(f)
    assert \"skill_name\" in data
    assert \"task_features\" in data
    assert \"model_recommendations\" in data
'"

        # 复制到临时目录用于后续测试
        cp "$TEST_SKILL/skill_analysis.json" "$TEST_TEMP_DIR/"
    else
        log_warn "skill_analysis.json 未生成，跳过相关测试"
    fi

    # 测试 3: 调研模型（模拟模式）
    # 注意：实际搜索需要 MCP 工具，这里仅测试脚本不报错
    run_test "research_models.py 基本执行" "python3 '$SKILL_DIR/scripts/research_models.py' '$TEST_TEMP_DIR/skill_analysis.json' 2>&1 | grep -q 'Research complete' || true"

    # 测试 4: 生成 WHICHMODEL
    if [ -f "$TEST_TEMP_DIR/research_results.json" ] || [ -f "$TEST_SKILL/research_results.json" ]; then
        RESEARCH_FILE="$TEST_TEMP_DIR/research_results.json"
        if [ ! -f "$RESEARCH_FILE" ]; then
            RESEARCH_FILE="$TEST_SKILL/research_results.json"
        fi

        run_test "generate_whichmodel.py 执行成功" "python3 '$SKILL_DIR/scripts/generate_whichmodel.py' '$RESEARCH_FILE' '$TEST_TEMP_DIR/skill_analysis.json'"

        # 测试 5: 检查输出文件
        if [ -f "$TEST_SKILL/WHICHMODEL_section.md" ]; then
            run_test "WHICHMODEL_section.md 生成且格式正确" "grep -q 'WHICHMODEL' '$TEST_SKILL/WHICHMODEL_section.md'"
        else
            log_warn "WHICHMODEL_section.md 未生成"
        fi
    else
        log_warn "research_results.json 未生成，跳过 WHICHMODEL 生成测试"
    fi

    # 清理临时文件
    log_info "清理测试文件..."
    rm -f "$TEST_SKILL/skill_analysis.json"
    rm -f "$TEST_SKILL/research_results.json"
    rm -f "$TEST_SKILL/WHICHMODEL_section.md"
    rm -rf "$TEST_TEMP_DIR"

else
    log_warn "测试技能 $TEST_SKILL 不存在，跳过功能测试"
fi

# ============================================
# 6. 表头一致性测试
# ============================================
echo ""
echo "========================================="
echo "第六部分：表头一致性测试"
echo "========================================="

run_test "SKILL.md 包含必需的 frontmatter 字段" "python3 -c '
import yaml
import re
with open(\"$SKILL_DIR/SKILL.md\", \"r\") as f:
    content = f.read()
    match = re.search(r\"^---\$(.*?)^---\$\", content, re.DOTALL | re.MULTILINE)
    if match:
        data = yaml.safe_load(match.group(1))
        assert \"name\" in data, \"Missing name\"
        assert \"description\" in data, \"Missing description\"
        assert \"metadata\" in data, \"Missing metadata\"
        assert \"short-description\" in data[\"metadata\"], \"Missing short-description\"
        assert \"keywords\" in data[\"metadata\"], \"Missing keywords\"
    else:
        exit(1)
'"

run_test "description 包含触发场景" "grep -q '当用户需要' '$SKILL_DIR/SKILL.md'"

run_test "keywords 包含核心术语" "grep -q '模型选择' '$SKILL_DIR/SKILL.md'"

# ============================================
# 7. 文档完整性测试
# ============================================
echo ""
echo "========================================="
echo "第七部分：文档完整性测试"
echo "========================================="

run_test "SKILL.md 包含工作流章节" "grep -q '## 工作流' '$SKILL_DIR/SKILL.md'"

run_test "SKILL.md 包含触发条件章节" "grep -q '## 触发条件' '$SKILL_DIR/SKILL.md'"

run_test "SKILL.md 包含输出规范章节" "grep -q '## 输出规范' '$SKILL_DIR/SKILL.md'"

run_test "README.md 包含快速开始章节" "grep -q '## 快速开始' '$SKILL_DIR/README.md'"

run_test "README.md 包含使用场景" "grep -q '## 典型使用场景' '$SKILL_DIR/README.md'"

# ============================================
# 8. 有机更新原则测试
# ============================================
echo ""
echo "========================================="
echo "第八部分：有机更新原则测试"
echo "========================================="

run_test "SKILL.md 避免补丁式更新标记" "! grep -qE '\\d{4}-\\d{2}-\\d{2}.*更新' '$SKILL_DIR/SKILL.md' || true"

run_test "SKILL.md 包含最高原则" "grep -q '最高原则' '$SKILL_DIR/SKILL.md'"

run_test "config.yaml 提取可配置参数" "python3 -c '
import yaml
with open(\"$SKILL_DIR/config.yaml\", \"r\") as f:
    config = yaml.safe_load(f)
    assert isinstance(config, dict), \"config.yaml should be a dict\"
    assert len(config) > 0, \"config.yaml should not be empty\"
'"

# ============================================
# 测试总结
# ============================================
echo ""
echo "========================================="
echo "测试总结"
echo "========================================="
echo "总测试数: $TESTS_TOTAL"
echo -e "${GREEN}通过: $TESTS_PASSED${NC}"
echo -e "${RED}失败: $TESTS_FAILED${NC}"
echo ""

if [ $TESTS_FAILED -eq 0 ]; then
    log_info "🎉 所有测试通过！"
    exit 0
else
    log_error "❌ 有 $TESTS_FAILED 个测试失败"
    exit 1
fi