ci: 5d4fb19

.env.example

@@ -0,0 +1,38 @@
+# ===== LLM =====
+# LLM provider: minimax | openai | anthropic | custom (OpenAI-compatible)
+LLM_PROVIDER=minimax
+LLM_BASE_URL=https://api.minimaxi.com/v1
+LLM_API_KEY=your-api-key-here
+LLM_MODEL=MiniMax-M3
+LLM_TEMPERATURE=0.2
+LLM_MAX_TOKENS=4096
+
+# ===== iWencai / 问财 API (used by 4 skills) =====
+IWENCAI_API_KEY=your-iwencai-api-key-here
+# IWENCAI_SKILL_ID_OVERRIDES=financial-query=hithink-financial-query,news-search=news-search
+
+# ===== Server =====
+DATA_PILOT_HOST=0.0.0.0
+DATA_PILOT_PORT=7860
+DATA_PILOT_ENV=development
+API_KEY=                         # optional; if set, clients must send X-API-Key
+
+# ===== CORS =====
+CORS_ALLOW_ORIGINS=http://localhost:5173,http://localhost:3000,http://127.0.0.1:5173
+
+# ===== Storage =====
+# Set to a Turso URL to use libSQL in production; leave empty to use local SQLite
+TURSO_DATABASE_URL=
+TURSO_AUTH_TOKEN=
+LOCAL_SQLITE_PATH=./data/findatapilot.db
+
+# ===== Agent =====
+AGENT_MAX_REFLECT_ROUNDS=5
+AGENT_MAX_PARALLEL_SKILLS=3
+AGENT_ENABLE_REFLECTION=true
+
+# ===== Observability =====
+LANGFUSE_PUBLIC_KEY=
+LANGFUSE_SECRET_KEY=
+LANGFUSE_HOST=
+LOG_LEVEL=INFO

.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.pyc
+.env
+data/
+logs/
+.venv/
+.DS_Store

Dockerfile

@@ -0,0 +1,30 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# System dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    curl ca-certificates git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Application code
+COPY app ./app
+
+# Data + log dirs (HF Spaces can persist /data across rebuilds)
+RUN mkdir -p /data/outputs /data/logs
+
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    DATA_PILOT_PORT=7860 \
+    DATA_PILOT_HOST=0.0.0.0
+
+EXPOSE 7860
+
+HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
+    CMD curl -fsS http://localhost:7860/api/health || exit 1
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]

README.md

@@ -0,0 +1,26 @@
+---
+title: Fin-DataPilot
+emoji: 📊
+colorFrom: blue
+colorTo: green
+sdk: docker
+app_port: 7860
+pinned: true
+license: mit
+short_description: NL financial data agent (LangGraph + 4 iWencai skills)
+---
+
+# Fin-DataPilot Backend
+
+Agent-based natural-language financial data platform. See root `README.md` for the full design.
+
+- Health: `GET /api/health`
+- Skills: `GET /api/skills` (and `PATCH /api/skills/{name}` to enable/disable)
+- Sessions: `POST /api/sessions`, `GET /api/sessions`, `GET /api/sessions/{id}`
+- Chat (SSE): `POST /api/agent/chat/stream`
+
+Configure secrets in the Space's "Variables and secrets" tab:
+- `LLM_BASE_URL` (default `https://api.minimaxi.com/v1`)
+- `LLM_API_KEY`
+- `IWENCAI_API_KEY`
+- `CORS_ALLOW_ORIGINS` (your GitHub Pages / Vercel frontend origin)

Skills/announcement-search/README.md

@@ -0,0 +1,252 @@
+# 公告搜索技能
+
+## 简介
+公告搜索技能是一个金融公告搜索引擎，通过调用同花顺问财的公告搜索接口，帮助用户查询A股、港股、基金、ETF等金融标的的最新公告信息。
+
+## 功能特性
+- 支持A股、港股、基金、ETF等金融标的公告查询
+- 覆盖定期财务报告、分红派息、回购增持、资产重组等多种公告类型
+- 智能查询处理，自动拆解复杂查询
+- 友好的命令行接口（CLI）
+- 支持批量搜索和数据导出
+- 完善的数据处理和错误处理机制
+
+## 快速开始
+
+### 环境要求
+- Python 3.7+
+- 有效的同花顺问财API Key
+
+### 安装步骤
+1. 克隆或下载本技能到本地
+2. 安装依赖：
+   ```bash
+   pip install -r scripts/requirements.txt
+   ```
+3. 设置环境变量：
+
+   **macOS / Linux (bash/zsh):**
+   ```bash
+   export IWENCAI_API_KEY="your_api_key_here"
+   ```
+
+   **Windows (PowerShell):**
+   ```powershell
+   $env:IWENCAI_API_KEY="your_api_key_here"
+   ```
+
+   **Windows (CMD):**
+   ```cmd
+   set IWENCAI_API_KEY=your_api_key_here
+   ```
+
+### 基本使用
+```bash
+# 使用CLI搜索公告
+python scripts/__main__.py "贵州茅台 公告"
+
+# 或者直接运行
+announcement-search "上市公司业绩预告"
+```
+
+## 使用示例
+
+### 搜索特定公司公告
+```bash
+announcement-search "贵州茅台最近一个月的公告"
+```
+
+### 查询业绩预告
+```bash
+announcement-search "上市公司业绩预告"
+```
+
+### 搜索分红公告
+```bash
+announcement-search "分红派息公告"
+```
+
+### 批量搜索
+```bash
+announcement-search --input queries.txt --output results.csv
+```
+
+## 配置说明
+
+### 环境变量配置
+```bash
+# 设置API Key
+export IWENCAI_API_KEY="your_api_key"
+
+# 可选：设置日志级别
+export LOG_LEVEL="INFO"
+```
+
+### 配置文件
+技能支持JSON配置文件，示例配置见`scripts/config.example.json`。
+
+## 直接API调用（curl示例）
+
+### curl调用示例
+```bash
+# 使用环境变量中的API Key
+curl -X POST "https://openapi.iwencai.com/v1/comprehensive/search" \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $IWENCAI_API_KEY" \
+  -H "X-Claw-Call-Type: normal" \
+  -H "X-Claw-Skill-Id: announcement-search" \
+  -H "X-Claw-Skill-Version: 1.0.0" \
+  -H "X-Claw-Plugin-Id: none" \
+  -H "X-Claw-Plugin-Version: none" \
+  -H "X-Claw-Trace-Id: $(python3 -c 'import secrets; print(secrets.token_hex(32))')" \
+  -d '{
+    "channels": ["announcement"],
+    "app_id": "AIME_SKILL",
+    "query": "贵州茅台 公告"
+  }'
+```
+
+### Windows PowerShell curl示例
+```powershell
+# 在PowerShell中设置环境变量后调用
+$traceId = python -c "import secrets; print(secrets.token_hex(32))"
+curl.exe -X POST "https://openapi.iwencai.com/v1/comprehensive/search" `
+  -H "Content-Type: application/json" `
+  -H "Authorization: Bearer $env:IWENCAI_API_KEY" `
+  -H "X-Claw-Call-Type: normal" `
+  -H "X-Claw-Skill-Id: announcement-search" `
+  -H "X-Claw-Skill-Version: 1.0.0" `
+  -H "X-Claw-Plugin-Id: none" `
+  -H "X-Claw-Plugin-Version: none" `
+  -H "X-Claw-Trace-Id: $traceId" `
+  -d '{
+    "channels": ["announcement"],
+    "app_id": "AIME_SKILL",
+    "query": "贵州茅台 公告"
+  }'
+```
+
+## 命令行参数
+
+### 基本参数
+- `query`: 搜索关键词（字符串）
+- `--input`, `-i`: 输入文件路径（用于批量搜索）
+- `--output`, `-o`: 输出文件路径
+- `--format`, `-f`: 输出格式（csv, json, txt）
+- `--limit`, `-l`: 结果数量限制
+- `--verbose`, `-v`: 详细输出模式
+
+### 使用示例
+```bash
+# 基本搜索，输出到控制台
+announcement-search "回购增持"
+
+# 搜索并保存为CSV文件
+announcement-search "资产重组" --output results.csv --format csv
+
+# 批量搜索
+announcement-search --input queries.txt --output results.json --format json
+
+# 限制结果数量
+announcement-search "定期报告" --limit 10
+```
+
+## 数据格式
+
+### 输入格式
+- 单次搜索：直接提供查询字符串
+- 批量搜索：文本文件，每行一个查询
+
+### 输出格式
+技能支持多种输出格式：
+
+#### CSV格式
+```csv
+title,summary,url,publish_date
+"某某公司2023年度业绩预告","公司预计2023年度净利润同比增长50%-70%","https://example.com/announcement/12345","2024-01-15 09:30:00"
+```
+
+#### JSON格式
+```json
+[
+  {
+    "title": "某某公司2023年度业绩预告",
+    "summary": "公司预计2023年度净利润同比增长50%-70%",
+    "url": "https://example.com/announcement/12345",
+    "publish_date": "2024-01-15 09:30:00"
+  }
+]
+```
+
+#### 文本格式
+```
+标题：某某公司2023年度业绩预告
+摘要：公司预计2023年度净利润同比增长50%-70%
+链接：https://example.com/announcement/12345
+发布时间：2024-01-15 09:30:00
+---
+```
+
+## 错误处理
+
+技能包含完善的错误处理机制：
+
+### 常见错误
+1. **API认证失败**: 检查API Key是否正确设置
+2. **网络连接错误**: 检查网络��接
+3. **参数错误**: 检查输入参数格式
+4. **API限制**: 避免频繁请求
+
+### 错误信息示例
+```bash
+# API认证失败
+错误：API认证失败，请检查IWENCAI_API_KEY环境变量
+
+# 网络错误
+错误：网络连接失败，请检查网络连接
+
+# 参数错误
+错误：查询参数不能为空
+```
+
+## 开发指南
+
+### 项目结构
+```
+announcement-search/
+├── README.md                    # 本文件
+├── SKILL.md                     # 技能详细文档
+├── references/
+│   └── api.md                   # API接口文档
+└── scripts/
+    ├── __main__.py              # CLI入口点
+    ├── config.py                # 配置文件
+    ├── config.example.json      # 配置示例文件
+    ├── requirements.txt         # Python依赖
+    ├── setup.py                 # 安装脚本
+    ├── announcement_search.py   # 核心搜索逻辑
+    └── utils.py                 # 工具函数
+```
+
+### 添加新功能
+1. 在`announcement_search.py`中添加新的搜索逻辑
+2. 在`__main__.py`中添加对应的命令行参数
+3. 更新文档说明
+
+## 许可证
+
+本技能遵循MIT许可证。
+
+## 支持与反馈
+
+如有问题或建议，请通过以下方式联系：
+- 提交Issue
+- 发送邮件至维护者
+
+## 更新日志
+
+### v1.0.0
+- 初始版本发布
+- 支持基本公告搜索功能
+- 提供CLI接口
+- 支持多种输出格式

Skills/announcement-search/SKILL.md

@@ -0,0 +1,210 @@
+---
+name: announcement-search
+description: 支持A股、港股、基金、ETF等金融标的公告的查询，同时公告类型包括不限于定期财务报告、分红派息、回购增持、资产重组等等。
+---
+
+# 公告搜索技能
+
+## 版本
+当前技能版本：1.0.0
+
+## 技能概述
+
+本技能是一个金融公告搜索引擎，通过调用同花顺问财的公告搜索接口，帮助用户查询A股、港股、基金、ETF等金融标的的最新公告信息。支持查询的公告类型包括但不限于：定期财务报告、分红派息、回购增持、资产重组、重大合同、业绩预告等。
+
+## API Key 获取与配置（首次使用必读）
+
+> 首次使用 - 获取 API Key  
+> 所有技能都需要 IWENCAI_API_KEY 环境变量才能使用。 如果用户尚未配置，按以下步骤引导：  
+>  
+> 步骤 1：获取 API Key  
+> 在浏览器内打同花顺i问财SkillHub页面：https://www.iwencai.com/skillhub  
+>  
+> 步骤 2：登录  
+>  
+> 步骤 3：点击具体的Skill，打开弹窗查看详情，在安装方式-Agent用户-找到您的IWENCAI_API_KEY这一段，复制  
+>  
+> 步骤 4：配置环境变量  
+> 获取到 API Key 后，直接复制指引文字发送给AI助手，或手动设置环境变量：
+
+### 跨平台环境变量设置
+
+**macOS / Linux (bash/zsh):**
+```bash
+export IWENCAI_API_KEY="your_api_key_here"
+```
+
+**Windows (PowerShell):**
+```powershell
+$env:IWENCAI_API_KEY="your_api_key_here"
+```
+
+**Windows (CMD):**
+```cmd
+set IWENCAI_API_KEY=your_api_key_here
+```
+
+## 技能功能
+
+### 1. 金融公告搜索
+- 搜索各类金融公告信息
+- 支持A股、港股、基金、ETF等金融标的
+- 覆盖定期财务报告、分红派息、回购增持、资产重组等多种公告类型
+- 支持中文关键词搜索
+
+### 2. 智能查询处理
+- 自动分析用户查询意图
+- 根据需求决定是否拆解复杂查询为多个简单查询
+- 示例：用户问"最近贵州茅台和五粮液有什么公告？"可以拆分为"贵州茅台 公告"和"五粮液 公告"两个查询
+- 根据查询复杂度决定调用接口的次数
+
+### 3. 数据评估与扩展
+- 自动评估搜索结果是否能回答用户问题
+- 如有必要，可调用其他技能或工具扩展数据
+- 对搜索结果进行质量评估和相关性排序
+
+### 4. 数据处理与返回
+- 对搜索结果进行排序、过滤和摘要处理
+- 生成结构化的数据结果
+- 将处理后的数据返回给大模型，帮助回答用户问题
+
+### 5. CLI支持
+- 提供友好的命令行接口
+- 支持基本搜索、批量搜索、数据导出等功能
+- 详细的命令行文档和使用示例
+
+## 使用场景
+
+### 何时调用本技能
+1. 当用户需要搜索上市公司最新公告时
+2. 当用户查询特定金融标的的公告信息时
+3. 当用户需要了解分红派息、回购增持等公告时
+4. 当用户查询定期财务报告（年报、季报）时
+5. 当用户需要获取资产重组、重大合同等公告信息时
+
+### 使用示例
+- "搜索贵州茅台最近一个月的公告"
+- "查询宁德时代的业绩预告"
+- "查看中国平安的分红公告"
+- "搜索最近有哪些公司发布了回购计划"
+- "查询创业板公司的年报公告"
+
+## 技术实现
+
+### API接口规范（遵循iwencai-skill-creator要求）
+
+#### 基础接口信息
+- **Base URL**: `https://openapi.iwencai.com`
+- **接口路径**: `/v1/comprehensive/search`
+- **请求方式**: POST（优先使用POST，符合规范要求）
+- **认证方式**: API Key (Bearer Token)，从环境变量 `IWENCAI_API_KEY` 读取
+
+#### 必需请求头（Claw Headers）
+所有发往问财OpenAPI网关的请求必须包含以下Header：
+
+| Header | 取值说明 | 本技能取值 |
+|--------|----------|------------|
+| `X-Claw-Call-Type` | `normal`：正常请求；`retry`：失败后的重试 | `normal` |
+| `X-Claw-Skill-Id` | 技能标识 | `announcement-search` |
+| `X-Claw-Skill-Version` | 当前技能版本号 | `1.0.0`（与技能版本一致） |
+| `X-Claw-Plugin-Id` | 插件ID（扩展字段） | `none` |
+| `X-Claw-Plugin-Version` | 插件版本（扩展字段） | `none` |
+| `X-Claw-Trace-Id` | **每次请求新生成**的64字符唯一追踪ID | 使用 `secrets.token_hex(32)` 生成 |
+
+#### 请求参数
+- **固定参数**: `channels: ["announcement"]`, `app_id: "AIME_SKILL"`
+- **可变参数**: `query` (用户问句)
+
+### 响应格式
+API返回的`data`字段包含以下信息：
+- `title`: 文章标题
+- `summary`: 文章摘要
+- `url`: 文章网址
+- `publish_date`: 文章发布时间 (格式: YYYY-MM-DD HH:MM:SS)
+
+### curl示例（脱敏）
+
+**Unix/Linux/macOS (bash/zsh):**
+```bash
+# 使用环境变量中的API Key
+curl -X POST "https://openapi.iwencai.com/v1/comprehensive/search" \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $IWENCAI_API_KEY" \
+  -H "X-Claw-Call-Type: normal" \
+  -H "X-Claw-Skill-Id: announcement-search" \
+  -H "X-Claw-Skill-Version: 1.0.0" \
+  -H "X-Claw-Plugin-Id: none" \
+  -H "X-Claw-Plugin-Version: none" \
+  -H "X-Claw-Trace-Id: $(python3 -c 'import secrets; print(secrets.token_hex(32))' 2>/dev/null || openssl rand -hex 32)" \
+  -d '{
+    "channels": ["announcement"],
+    "app_id": "AIME_SKILL",
+    "query": "贵州茅台 公告"
+  }'
+```
+
+**Windows (PowerShell):**
+```powershell
+# 首先设置环境变量（如果尚未设置）
+$env:IWENCAI_API_KEY="your_api_key_here"
+
+# 生成64字符Trace ID
+$traceId = -join ((48..57) + (97..102) | Get-Random -Count 64 | % { [char]$_ })
+
+# 发送请求
+$headers = @{
+    "Content-Type" = "application/json"
+    "Authorization" = "Bearer $env:IWENCAI_API_KEY"
+    "X-Claw-Call-Type" = "normal"
+    "X-Claw-Skill-Id" = "announcement-search"
+    "X-Claw-Skill-Version" = "1.0.0"
+    "X-Claw-Plugin-Id" = "none"
+    "X-Claw-Plugin-Version" = "none"
+    "X-Claw-Trace-Id" = $traceId
+}
+
+$body = @{
+    channels = @("announcement")
+    app_id = "AIME_SKILL"
+    query = "贵州茅台 公告"
+} | ConvertTo-Json
+
+Invoke-RestMethod -Uri "https://openapi.iwencai.com/v1/comprehensive/search" -Method Post -Headers $headers -Body $body
+```
+
+**通用说明：**
+- Trace ID必须是64字符十六进制字符串，每次请求新生成
+- API Key必须从环境变量 `IWENCAI_API_KEY` 读取，禁止硬编码
+- 所有Claw headers必须正确设置
+
+## 安装与使用
+
+### 快速开始
+1. 按照前面的"API Key 获取与配置"章节设置环境变量
+2. 使用技能搜索公告：`announcement-search "贵州茅台 公告"`
+
+### 配置文件（可选）
+技能支持通过配置文件管理API Key等敏感信息，配置文件示例见`scripts/config.example.json`。
+
+### CLI使用示例
+```bash
+# 基本搜索
+announcement-search "上市公司业绩预告"
+
+# 批量搜索（从文件读取查询）
+announcement-search --input queries.txt --output results.csv
+
+# 指定输出格式
+announcement-search "分红派息" --format json
+```
+
+## 注意事项
+
+1. **API Key安全**: 请妥善保管API Key，不要将其暴露在客户端代码中
+2. **请求频率**: 请遵守API使用限制，避免频繁请求
+3. **数据准确性**: 请注意数据时效性
+4. **错误处理**: 技能包含完善的错误处理机制，会提示用户相关错误信息
+
+## 支持与反馈
+
+如有问题或需要技术支持，请联系技能维护者。技能会持续更新以提供更好的公告搜索体验。

Skills/announcement-search/references/api.md

@@ -0,0 +1,175 @@
+# 问财公告搜索 API 文档
+
+## 概述
+问财公告搜索 API 提供公告信息的搜索功能，通过用户问句查询相关公告信息。
+
+## 基础信息
+- **Base URL**: `https://openapi.iwencai.com`
+- **接口路径**: `/v1/comprehensive/search`
+- **请求方式**: POST
+- **Content-Type**: `application/json`
+
+## 认证
+API 使用 API Key 进行认证，需要在请求头中设置：
+- **Header**: `Authorization: Bearer {IWENCAI_API_KEY}`
+- **环境变量**: `IWENCAI_API_KEY` (用户侧申请的 API Key)
+
+## 请求参数
+
+### 请求头 (Headers)
+| 参数名 | 类型 | 必填 | 说明 |
+|--------|------|------|------|
+| Content-Type | string | 是 | 必须设置为 `application/json` |
+| Authorization | string | 是 | Bearer token 认证，格式: `Bearer {IWENCAI_API_KEY}` |
+
+### 请求体 (Body)
+请求体为 JSON 格式，包含以下参数：
+
+#### 固定参数
+| 参数名 | 类型 | 必填 | 说明 | 示例值 |
+|--------|------|------|------|--------|
+| channels | array | 是 | 搜索渠道类型 | `["announcement"]` |
+| app_id | string | 是 | 应用 ID | `"AIME_SKILL"` |
+
+#### 可变参数
+| 参数名 | 类型 | 必填 | 说明 | 示例值 |
+|--------|------|------|------|--------|
+| query | string | 是 | 用户问句，搜索关键词 | `"上市公司业绩预告"` |
+
+### 请求示例
+```json
+{
+  "channels": ["announcement"],
+  "app_id": "AIME_SKILL",
+  "query": "上市公司业绩预告"
+}
+```
+
+## 响应
+
+### 响应格式
+响应为 JSON 格式，包含以下字段：
+
+| 字段名 | 类型 | 说明 |
+|--------|------|------|
+| data | array | 返回的文章信息列表 |
+
+### data 字段结构
+`data` 数组中的每个元素包含以下字段：
+
+| 字段名 | 类型 | 说明 | 格式 |
+|--------|------|------|------|
+| title | string | 文章标题 | - |
+| summary | string | 文章摘要 | - |
+| url | string | 文章网址 | URL 格式 |
+| publish_date | string | 文章发布时间 | `YYYY-MM-DD HH:MM:SS` |
+
+### 响应示例
+```json
+{
+  "data": [
+    {
+      "title": "某某公司2023年度业绩预告",
+      "summary": "公司预计2023年度净利润同比增长50%-70%",
+      "url": "https://example.com/announcement/12345",
+      "publish_date": "2024-01-15 09:30:00"
+    },
+    {
+      "title": "另一家公司重大合同公告",
+      "summary": "公司与客户签订重大销售合同，金额约10亿元",
+      "url": "https://example.com/announcement/12346",
+      "publish_date": "2024-01-14 16:45:00"
+    }
+  ]
+}
+```
+
+## 错误处理
+
+### HTTP 状态码
+| 状态码 | 说明 |
+|--------|------|
+| 200 | 请求成功 |
+| 400 | 请求参数错误 |
+| 401 | 认证失败 |
+| 500 | 服务器内部错误 |
+
+### 错误响应示例
+```json
+{
+  "error": {
+    "code": "AUTH_FAILED",
+    "message": "API Key 无效或已过期"
+  }
+}
+```
+
+## 使用示例
+
+### Python 示例
+```python
+import requests
+import os
+
+# 从环境变量获取 API Key
+api_key = os.getenv("IWENCAI_API_KEY")
+
+# 请求头
+headers = {
+    "Content-Type": "application/json",
+    "Authorization": f"Bearer {api_key}"
+}
+
+# 请求体
+payload = {
+    "channels": ["announcement"],
+    "app_id": "AIME_SKILL",
+    "query": "上市公司业绩预告"
+}
+
+# 发送请求
+response = requests.post(
+    "https://openapi.iwencai.com/v1/comprehensive/search",
+    headers=headers,
+    json=payload
+)
+
+# 处理响应
+if response.status_code == 200:
+    data = response.json()
+    for article in data["data"]:
+        print(f"标题: {article['title']}")
+        print(f"摘要: {article['summary']}")
+        print(f"发布时间: {article['publish_date']}")
+        print(f"链接: {article['url']}")
+        print("---")
+else:
+    print(f"请求失败: {response.status_code}")
+    print(response.text)
+```
+
+### cURL 示例
+```bash
+curl -X POST \
+  https://openapi.iwencai.com/v1/comprehensive/search \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $IWENCAI_API_KEY" \
+  -d '{
+    "channels": ["announcement"],
+    "app_id": "AIME_SKILL",
+    "query": "上市公司业绩预告"
+  }'
+```
+
+## 注意事项
+1. **API Key 安全**: 请妥善保管 API Key，不要将其暴露在客户端代码中
+2. **请求频率**: 请遵守 API 使用限制，避免频繁请求
+3. **参数格式**: `channels` 参数必须为数组格式，且包含 `"announcement"`
+4. **时间格式**: `publish_date` 字段使用 24 小时制时间格式
+5. **错误处理**: 建议实现完善的错误处理机制
+
+## 更新日志
+- **v1.0.0** (初始版本): 基础公告搜索功能
+
+## 支持
+如有问题或需要技术支持，请联系 API 提供商。

Skills/announcement-search/scripts/__main__.py

@@ -0,0 +1,234 @@
+#!/usr/bin/env python3
+import argparse
+import sys
+import os
+import time
+from typing import List, Dict, Any
+
+from config import config
+from utils import Utils
+from announcement_search import AnnouncementSearch
+
+def parse_arguments():
+    parser = argparse.ArgumentParser(
+        description="公告搜索工具 - 搜索A股、港股、基金、ETF等金融标的公告",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+使用示例:
+  %(prog)s "贵州茅台 公告"                    # 基本搜索
+  %(prog)s "上市公司业绩预告" --limit 5       # 限制结果数量
+  %(prog)s "分红派息" --format json          # 指定输出格式
+  %(prog)s --input queries.txt --output results.csv  # 批量搜索
+  %(prog)s --help                            # 显示帮助信息
+        """
+    )
+    
+    parser.add_argument(
+        "query",
+        nargs="?",
+        help="搜索关键词，例如：'贵州茅台 公告'、'上市公司业绩预告'"
+    )
+    
+    parser.add_argument(
+        "-i", "--input",
+        help="输入文件路径，包含多个查询（每行一个）"
+    )
+    
+    parser.add_argument(
+        "-o", "--output",
+        help="输出文件路径，保存搜索结果"
+    )
+    
+    parser.add_argument(
+        "-f", "--format",
+        choices=["csv", "json", "txt"],
+        default=config.get_output_config()["default_format"],
+        help="输出格式（默认: %(default)s）"
+    )
+    
+    parser.add_argument(
+        "-l", "--limit",
+        type=int,
+        default=config.get_search_config()["default_limit"],
+        help="每个查询的结果数量限制（默认: %(default)d）"
+    )
+    
+    parser.add_argument(
+        "-v", "--verbose",
+        action="store_true",
+        help="详细输出模式"
+    )
+    
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"公告搜索工具 v{config.get_skill_config()['version']}"
+    )
+    
+    parser.add_argument(
+        "--config",
+        help="配置文件路径"
+    )
+    
+    return parser.parse_args()
+
+def show_platform_help():
+    print("\n跨平台环境变量设置说明:")
+    print("=" * 50)
+    print("macOS / Linux (bash/zsh):")
+    print("  export IWENCAI_API_KEY=\"your_api_key_here\"")
+    print()
+    print("Windows (PowerShell):")
+    print("  $env:IWENCAI_API_KEY=\"your_api_key_here\"")
+    print()
+    print("Windows (CMD):")
+    print("  set IWENCAI_API_KEY=your_api_key_here")
+    print()
+    print("获取API Key:")
+    print("1. 访问 https://www.iwencai.com/skillhub")
+    print("2. 登录您的账户")
+    print("3. 选择公告搜索技能，复制API Key")
+    print("=" * 50)
+
+def validate_arguments(args):
+    if not args.query and not args.input:
+        print("错误: 必须提供查询关键词或输入文件")
+        return False
+    
+    if args.limit > config.get_search_config()["max_limit"]:
+        print(f"警告: 结果数量限制超过最大值 {config.get_search_config()['max_limit']}，已自动调整")
+        args.limit = config.get_search_config()["max_limit"]
+    
+    if args.output and args.format not in config.get_output_config()["supported_formats"]:
+        print(f"错误: 不支持的输出格式 '{args.format}'")
+        print(f"支持的格式: {', '.join(config.get_output_config()['supported_formats'])}")
+        return False
+    
+    return True
+
+def save_results(results: List[Dict[str, Any]], args):
+    if not args.output:
+        return True
+    
+    file_ext = Utils.get_file_extension(args.output)
+    
+    if file_ext != args.format:
+        new_output = f"{os.path.splitext(args.output)[0]}.{args.format}"
+        print(f"警告: 输出文件扩展名与格式不匹配，已自动调整为: {new_output}")
+        args.output = new_output
+    
+    if args.format == "csv":
+        return Utils.save_to_csv(results, args.output)
+    elif args.format == "json":
+        return Utils.save_to_json(results, args.output)
+    elif args.format == "txt":
+        return Utils.save_to_txt(results, args.output)
+    else:
+        print(f"错误: 不支持的输出格式 '{args.format}'")
+        return False
+
+def display_results(results: List[Dict[str, Any]], query: str, execution_time: float):
+    if not results:
+        print(f"\n对于查询 '{query}'，未找到相关公告信息。")
+        return
+    
+    print(f"\n搜索完成！")
+    print(f"查询: {query}")
+    print(f"找到 {len(results)} 条相关公告")
+    print(f"执行时间: {Utils.format_execution_time(execution_time)}")
+    print("=" * 60)
+    
+    for i, result in enumerate(results, 1):
+        print(f"{i}. {result.get('title', '')}")
+        
+        if args.verbose:
+            print(f"   摘要: {result.get('summary', '')}")
+            print(f"   发布时间: {result.get('publish_date', '')}")
+            print(f"   链接: {result.get('url', '')}")
+        else:
+            summary = result.get('summary', '')
+            if len(summary) > 100:
+                summary = summary[:100] + "..."
+            print(f"   摘要: {summary}")
+            print(f"   发布时间: {result.get('publish_date', '')}")
+        
+        print()
+
+def main():
+    global args
+    args = parse_arguments()
+    
+    if not validate_arguments(args):
+        sys.exit(1)
+    
+    log_level = "DEBUG" if args.verbose else "INFO"
+    Utils.setup_logging(log_level)
+    
+    if not config.validate():
+        print("错误: 配置验证失败")
+        print("请检查 IWENCAI_API_KEY 环境变量是否设置")
+        print()
+        show_platform_help()
+        sys.exit(1)
+    
+    search = AnnouncementSearch()
+    
+    all_results = []
+    
+    if args.input:
+        queries = Utils.read_queries_from_file(args.input)
+        if not queries:
+            print(f"错误: 无法从文件读取查询: {args.input}")
+            sys.exit(1)
+        
+        print(f"开始批量搜索，共 {len(queries)} 个查询")
+        
+        batch_results = search.batch_search(queries, args.limit)
+        
+        for query, (success, results, message) in batch_results.items():
+            if success:
+                all_results.extend(results)
+                print(f"✓ {query}: 找到 {len(results)} 条结果")
+            else:
+                print(f"✗ {query}: {message}")
+        
+        if args.output:
+            save_success = save_results(all_results, args)
+            if save_success:
+                print(f"\n所有结果已保存到: {args.output}")
+        
+        print(f"\n批量搜索完成，总共找到 {len(all_results)} 条公告")
+    else:
+        start_time = time.time()
+        
+        success, results, message = search.search(args.query, args.limit)
+        
+        execution_time = Utils.calculate_execution_time(start_time)
+        
+        if success:
+            all_results = results
+            
+            if args.output:
+                save_success = save_results(all_results, args)
+                if save_success:
+                    print(f"结果已保存到: {args.output}")
+            
+            display_results(all_results, args.query, execution_time)
+        else:
+            print(f"\n搜索失败: {message}")
+            sys.exit(1)
+    
+    sys.exit(0)
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        print("\n\n操作被用户中断")
+        sys.exit(130)
+    except Exception as e:
+        print(f"\n发生错误: {e}")
+        if args and args.verbose:
+            import traceback
+            traceback.print_exc()
+        sys.exit(1)

Skills/announcement-search/scripts/announcement_search.py

@@ -0,0 +1,323 @@
+import requests
+import json
+import time
+import logging
+import secrets
+from typing import Dict, List, Any, Optional, Tuple
+from datetime import datetime
+
+from config import config
+from utils import Utils
+
+logger = logging.getLogger(__name__)
+
+class AnnouncementSearch:
+    def __init__(self):
+        self.api_config = config.get_api_config()
+        self.search_config = config.get_search_config()
+        self.api_key = config.get_api_key()
+        
+        self.base_url = self.api_config["base_url"]
+        self.endpoint = self.api_config["endpoint"]
+        self.timeout = self.api_config["timeout"]
+        self.max_retries = self.api_config["max_retries"]
+        
+        self.channels = self.search_config["channels"]
+        self.app_id = self.search_config["app_id"]
+        
+        skill_config = config.get_skill_config()
+        self.skill_id = skill_config["id"]
+        self.skill_version = skill_config["version"]
+        self.plugin_id = skill_config["plugin_id"]
+        self.plugin_version = skill_config["plugin_version"]
+        
+        self.base_headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}"
+        }
+    
+    def _generate_trace_id(self) -> str:
+        return secrets.token_hex(32)
+    
+    def _get_claw_headers(self, trace_id: str) -> Dict[str, str]:
+        return {
+            "X-Claw-Call-Type": "normal",
+            "X-Claw-Skill-Id": self.skill_id,
+            "X-Claw-Skill-Version": self.skill_version,
+            "X-Claw-Plugin-Id": self.plugin_id,
+            "X-Claw-Plugin-Version": self.plugin_version,
+            "X-Claw-Trace-Id": trace_id
+        }
+    
+    def search(self, query: str, limit: int = 10) -> Dict[str, Any]:
+        if not Utils.validate_query(query):
+            return {
+                "success": False,
+                "error": "查询参数无效",
+                "raw_response": None
+            }
+        
+        logger.info(f"搜索公告: {query}")
+        
+        payload = {
+            "channels": self.channels,
+            "app_id": self.app_id,
+            "query": query
+        }
+        
+        url = f"{self.base_url}{self.endpoint}"
+        
+        for attempt in range(self.max_retries):
+            try:
+                trace_id = self._generate_trace_id()
+                claw_headers = self._get_claw_headers(trace_id)
+                headers = {**self.base_headers, **claw_headers}
+                
+                logger.debug(f"请求URL: {url}")
+                logger.debug(f"请求参数: {payload}")
+                logger.debug(f"Trace ID: {trace_id}")
+                logger.debug(f"Claw Headers: {claw_headers}")
+                
+                response = requests.post(
+                    url,
+                    headers=headers,
+                    json=payload,
+                    timeout=self.timeout
+                )
+                
+                logger.debug(f"响应状态码: {response.status_code}")
+                
+                try:
+                    raw_response = response.json()
+                except json.JSONDecodeError:
+                    raw_response = {"error": "响应不是有效的JSON格式", "raw_text": response.text}
+                
+                result = {
+                    "success": response.status_code == 200,
+                    "status_code": response.status_code,
+                    "trace_id": trace_id,
+                    "raw_response": raw_response,
+                    "query": query
+                }
+                
+                if response.status_code == 200:
+                    logger.info(f"API调用成功，Trace ID: {trace_id}")
+                    return result
+                elif response.status_code == 429:
+                    logger.warning("请求过于频繁，等待后重试")
+                    if attempt < self.max_retries - 1:
+                        time.sleep(2 ** attempt)
+                        continue
+                    else:
+                        logger.warning("请求过于频繁，已达到最大重试次数")
+                        return result
+                else:
+                    logger.warning(f"API调用失败，状态码: {response.status_code}, Trace ID: {trace_id}")
+                    return result
+            
+            except requests.exceptions.Timeout:
+                logger.warning(f"请求超时 (尝试 {attempt + 1}/{self.max_retries})")
+                if attempt < self.max_retries - 1:
+                    time.sleep(1)
+                    continue
+                else:
+                    logger.error("请求超时，已达到最大重试次数")
+                    return {
+                        "success": False,
+                        "error": "请求超时，请检查网络连接",
+                        "raw_response": None,
+                        "query": query
+                    }
+            
+            except requests.exceptions.ConnectionError:
+                logger.error("网络连接错误")
+                return {
+                    "success": False,
+                    "error": "网络连接错误，请检查网络连接",
+                    "raw_response": None,
+                    "query": query
+                }
+            
+            except requests.exceptions.RequestException as e:
+                logger.error(f"请求异常: {e}")
+                return {
+                    "success": False,
+                    "error": f"请求异常: {str(e)}",
+                    "raw_response": None,
+                    "query": query
+                }
+            
+            except json.JSONDecodeError as e:
+                logger.error(f"JSON解析错误: {e}")
+                return {
+                    "success": False,
+                    "error": f"响应数据解析错误: {str(e)}",
+                    "raw_response": None,
+                    "query": query
+                }
+            
+            except Exception as e:
+                logger.error(f"未知错误: {e}")
+                return {
+                    "success": False,
+                    "error": f"未知错误: {str(e)}",
+                    "raw_response": None,
+                    "query": query
+                }
+        
+        return {
+            "success": False,
+            "error": "搜索失败，已达到最大重试次数",
+            "raw_response": None,
+            "query": query
+        }
+    
+    def _process_results(self, results: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        processed = []
+        
+        for result in results:
+            processed_result = {
+                "title": result.get("title", ""),
+                "summary": result.get("summary", ""),
+                "url": result.get("url", ""),
+                "publish_date": result.get("publish_date", "")
+            }
+            
+            processed.append(processed_result)
+        
+        return processed
+    
+    def batch_search(self, queries: List[str], limit_per_query: int = 10) -> Dict[str, Dict[str, Any]]:
+        results = {}
+        
+        logger.info(f"开始批量搜索，共 {len(queries)} 个查询")
+        
+        for i, query in enumerate(queries, 1):
+            logger.info(f"处理查询 {i}/{len(queries)}: {query}")
+            
+            result = self.search(query, limit_per_query)
+            results[query] = result
+            
+            time.sleep(config.get_performance_config().get("request_delay", 0.5))
+        
+        logger.info("批量搜索完成")
+        return results
+    
+    def smart_query_analysis(self, user_query: str) -> List[str]:
+        logger.info(f"智能分析用户查询: {user_query}")
+        
+        queries = []
+        
+        if "和" in user_query or "与" in user_query or "、" in user_query:
+            parts = user_query.replace("和", ",").replace("与", ",").replace("、", ",").split(",")
+            for part in parts:
+                part = part.strip()
+                if part:
+                    queries.append(f"{part} 公告")
+        else:
+            queries.append(user_query)
+        
+        logger.info(f"分析后的查询列表: {queries}")
+        return queries
+    
+    def evaluate_results(self, query: str, results: List[Dict[str, Any]]) -> Tuple[bool, str]:
+        if not results:
+            return False, "未找到相关结果"
+        
+        query_keywords = set(query.lower().split())
+        
+        relevance_scores = []
+        for result in results:
+            title = result.get("title", "").lower()
+            summary = result.get("summary", "").lower()
+            
+            score = 0
+            for keyword in query_keywords:
+                if keyword in title:
+                    score += 3
+                if keyword in summary:
+                    score += 1
+            
+            relevance_scores.append(score)
+        
+        avg_score = sum(relevance_scores) / len(relevance_scores) if relevance_scores else 0
+        
+        if avg_score >= 2:
+            return True, "结果相关性较高"
+        elif avg_score >= 1:
+            return True, "结果相关性一般"
+        else:
+            return False, "结果相关性较低"
+    
+    def generate_search_summary(self, query: str, results: List[Dict[str, Any]]) -> str:
+        if not results:
+            return f"对于查询 '{query}'，未找到相关公告信息。"
+        
+        summary_lines = []
+        summary_lines.append(f"搜索查询：{query}")
+        summary_lines.append(f"找到 {len(results)} 条相关公告：")
+        summary_lines.append("")
+        
+        for i, result in enumerate(results[:5], 1):
+            title = result.get("title", "")
+            publish_date = result.get("publish_date", "")
+            summary_lines.append(f"{i}. {title} ({publish_date})")
+        
+        if len(results) > 5:
+            summary_lines.append(f"... 还有 {len(results) - 5} 条结果")
+
+        return "\n".join(summary_lines)
+
+if __name__ == "__main__":
+    Utils.setup_logging("INFO")
+    
+    search = AnnouncementSearch()
+    
+    test_queries = [
+        "贵州茅台 公告",
+        "上市公司业绩预告",
+        "分红派息"
+    ]
+    
+    for query in test_queries:
+        print(f"\n测试查询: {query}")
+        print("-" * 50)
+        
+        result = search.search(query, limit=3)
+        
+        if result["success"]:
+            print(f"状态: API调用成功")
+            print(f"Trace ID: {result['trace_id']}")
+            print(f"状态码: {result['status_code']}")
+            
+            raw_response = result["raw_response"]
+            if raw_response and "data" in raw_response:
+                data = raw_response.get("data", [])
+                print(f"找到 {len(data)} 条结果:")
+                
+                for i, item in enumerate(data[:5], 1):
+                    print(f"{i}. {item.get('title', '')}")
+                    print(f"   发布时间: {item.get('publish_date', '')}")
+                    summary = item.get('summary', '')
+                    if summary:
+                        print(f"   摘要: {summary[:50]}...")
+                    print()
+            else:
+                print(f"API响应: {raw_response}")
+        else:
+            print(f"错误: {result.get('error', '未知错误')}")
+            print(f"API响应: {result.get('raw_response', '无响应')}")
+    
+    print("\n测试智能查询分析:")
+    complex_query = "贵州茅台和五粮液最近有什么公告"
+    analyzed_queries = search.smart_query_analysis(complex_query)
+    print(f"原始查询: {complex_query}")
+    print(f"分析后的查询: {analyzed_queries}")
+    
+    print("\n测试结果评估:")
+    test_results = [
+        {"title": "贵州茅台2023年度业绩预告", "summary": "公司预计2023年度净利润增长", "url": "", "publish_date": ""},
+        {"title": "五粮液分红公告", "summary": "公司宣布年度分红方案", "url": "", "publish_date": ""}
+    ]
+    relevance, evaluation = search.evaluate_results("贵州茅台 业绩预告", test_results)
+    print(f"相关性: {relevance}, 评估: {evaluation}")

Skills/announcement-search/scripts/config.example.json

@@ -0,0 +1,39 @@
+{
+  "api": {
+    "base_url": "https://openapi.iwencai.com",
+    "endpoint": "/v1/comprehensive/search",
+    "timeout": 30,
+    "max_retries": 3
+  },
+  "auth": {
+    "api_key_env_var": "IWENCAI_API_KEY",
+    "api_key": "your_api_key_here"
+  },
+  "search": {
+    "channels": ["announcement"],
+    "app_id": "AIME_SKILL",
+    "default_limit": 10,
+    "max_limit": 50
+  },
+  "output": {
+    "default_format": "csv",
+    "supported_formats": ["csv", "json", "txt"],
+    "date_format": "%Y-%m-%d %H:%M:%S",
+    "encoding": "utf-8"
+  },
+  "logging": {
+    "level": "INFO",
+    "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    "file": "announcement_search.log"
+  },
+  "cache": {
+    "enabled": false,
+    "ttl": 3600,
+    "cache_dir": ".cache"
+  },
+  "performance": {
+    "max_concurrent_requests": 5,
+    "request_delay": 0.5,
+    "batch_size": 10
+  }
+}

Skills/announcement-search/scripts/config.py

@@ -0,0 +1,138 @@
+import os
+import json
+import logging
+from typing import Dict, Any, Optional
+
+class Config:
+    def __init__(self, config_path: Optional[str] = None):
+        self.config = self._load_config(config_path)
+        self._setup_logging()
+    
+    def _load_config(self, config_path: Optional[str] = None) -> Dict[str, Any]:
+        default_config = {
+            "api": {
+                "base_url": "https://openapi.iwencai.com",
+                "endpoint": "/v1/comprehensive/search",
+                "timeout": 30,
+                "max_retries": 3
+            },
+            "auth": {
+                "api_key_env_var": "IWENCAI_API_KEY",
+                "api_key": os.getenv("IWENCAI_API_KEY", "")
+            },
+            "search": {
+                "channels": ["announcement"],
+                "app_id": "AIME_SKILL",
+                "default_limit": 10,
+                "max_limit": 50
+            },
+            "skill": {
+                "id": "announcement-search",
+                "version": "1.0.0",
+                "plugin_id": "none",
+                "plugin_version": "none"
+            },
+            "output": {
+                "default_format": "csv",
+                "supported_formats": ["csv", "json", "txt"],
+                "date_format": "%Y-%m-%d %H:%M:%S",
+                "encoding": "utf-8"
+            },
+            "logging": {
+                "level": os.getenv("LOG_LEVEL", "INFO"),
+                "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+                "file": "announcement_search.log"
+            },
+            "cache": {
+                "enabled": False,
+                "ttl": 3600,
+                "cache_dir": ".cache"
+            },
+            "performance": {
+                "max_concurrent_requests": 5,
+                "request_delay": 0.5,
+                "batch_size": 10
+            }
+        }
+        
+        if config_path and os.path.exists(config_path):
+            try:
+                with open(config_path, 'r', encoding='utf-8') as f:
+                    file_config = json.load(f)
+                    default_config = self._merge_configs(default_config, file_config)
+            except Exception as e:
+                logging.warning(f"Failed to load config file {config_path}: {e}")
+        
+        return default_config
+    
+    def _merge_configs(self, default: Dict[str, Any], custom: Dict[str, Any]) -> Dict[str, Any]:
+        result = default.copy()
+        for key, value in custom.items():
+            if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+                result[key] = self._merge_configs(result[key], value)
+            else:
+                result[key] = value
+        return result
+    
+    def _setup_logging(self):
+        log_config = self.config["logging"]
+        log_level = getattr(logging, log_config["level"].upper(), logging.INFO)
+        
+        logging.basicConfig(
+            level=log_level,
+            format=log_config["format"],
+            handlers=[
+                logging.StreamHandler(),
+                logging.FileHandler(log_config["file"])
+            ]
+        )
+    
+    def get_api_key(self) -> str:
+        api_key = self.config["auth"]["api_key"]
+        if not api_key:
+            raise ValueError("API Key not found. Please set IWENCAI_API_KEY environment variable.")
+        return api_key
+    
+    def get_api_config(self) -> Dict[str, Any]:
+        return self.config["api"]
+    
+    def get_search_config(self) -> Dict[str, Any]:
+        return self.config["search"]
+    
+    def get_output_config(self) -> Dict[str, Any]:
+        return self.config["output"]
+    
+    def get_cache_config(self) -> Dict[str, Any]:
+        return self.config["cache"]
+    
+    def get_performance_config(self) -> Dict[str, Any]:
+        return self.config["performance"]
+    
+    def get_skill_config(self) -> Dict[str, Any]:
+        return self.config["skill"]
+    
+    def validate(self) -> bool:
+        try:
+            api_key = self.get_api_key()
+            if not api_key or api_key == "your_api_key_here":
+                return False
+            
+            search_config = self.get_search_config()
+            if not search_config.get("channels") or "announcement" not in search_config["channels"]:
+                return False
+            
+            if not search_config.get("app_id"):
+                return False
+            
+            return True
+        except Exception as e:
+            logging.error(f"Config validation failed: {e}")
+            return False
+
+config = Config()
+
+if __name__ == "__main__":
+    print("Configuration loaded successfully")
+    print(f"API Base URL: {config.get_api_config()['base_url']}")
+    print(f"Search Channels: {config.get_search_config()['channels']}")
+    print(f"Default Output Format: {config.get_output_config()['default_format']}")

Skills/announcement-search/scripts/example_usage.py

@@ -0,0 +1,253 @@
+#!/usr/bin/env python3
+"""
+公告搜索工具使用示例
+"""
+
+import os
+import sys
+import time
+from datetime import datetime
+
+# 添加当前目录到Python路径
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from config import config
+from utils import Utils
+from announcement_search import AnnouncementSearch
+
+def setup_environment():
+    """设置环境"""
+    print("=" * 60)
+    print("公告搜索工具使用示例")
+    print("=" * 60)
+    
+    # 检查API Key
+    api_key = os.getenv("IWENCAI_API_KEY")
+    if not api_key:
+        print("警告: IWENCAI_API_KEY 环境变量未设置")
+        print("请设置环境变量: export IWENCAI_API_KEY='your_api_key'")
+        return False
+    
+    print(f"✓ API Key 已设置")
+    print(f"✓ 配置验证: {'通过' if config.validate() else '失败'}")
+    return True
+
+def example_basic_search():
+    """示例1: 基本搜索"""
+    print("\n" + "=" * 60)
+    print("示例1: 基本搜索")
+    print("=" * 60)
+    
+    search = AnnouncementSearch()
+    
+    # 搜索贵州茅台公告
+    query = "贵州茅台 公告"
+    print(f"搜索: {query}")
+    
+    start_time = time.time()
+    success, results, message = search.search(query, limit=5)
+    execution_time = time.time() - start_time
+    
+    if success:
+        print(f"状态: {message}")
+        print(f"找到 {len(results)} 条结果")
+        print(f"执行时间: {execution_time:.2f}秒")
+        
+        for i, result in enumerate(results, 1):
+            print(f"\n{i}. {result.get('title', '')}")
+            print(f"   发布时间: {result.get('publish_date', '')}")
+            print(f"   摘要: {result.get('summary', '')[:80]}...")
+    else:
+        print(f"错误: {message}")
+
+def example_multiple_queries():
+    """示例2: 多个查询"""
+    print("\n" + "=" * 60)
+    print("示例2: 多个查询")
+    print("=" * 60)
+    
+    search = AnnouncementSearch()
+    
+    queries = [
+        "上市公司业绩预告",
+        "分红派息公告",
+        "回购增持公告"
+    ]
+    
+    for query in queries:
+        print(f"\n搜索: {query}")
+        
+        success, results, message = search.search(query, limit=3)
+        
+        if success:
+            print(f"  找到 {len(results)} 条结果")
+            if results:
+                print(f"  最新公告: {results[0].get('title', '')}")
+        else:
+            print(f"  错误: {message}")
+        
+        time.sleep(1)  # 避免请求过于频繁
+
+def example_smart_query_analysis():
+    """示例3: 智能查询分析"""
+    print("\n" + "=" * 60)
+    print("示例3: 智能查询分析")
+    print("=" * 60)
+    
+    search = AnnouncementSearch()
+    
+    complex_queries = [
+        "贵州茅台和五粮液最近有什么公告",
+        "查看宁德时代、比亚迪的业绩预告",
+        "搜索分红和回购相关的公告"
+    ]
+    
+    for query in complex_queries:
+        print(f"\n原始查询: {query}")
+        
+        analyzed_queries = search.smart_query_analysis(query)
+        print(f"分析后的查询: {analyzed_queries}")
+        
+        # 执行第一个分析后的查询作为示例
+        if analyzed_queries:
+            success, results, message = search.search(analyzed_queries[0], limit=2)
+            if success:
+                print(f"  示例结果: 找到 {len(results)} 条相关公告")
+
+def example_batch_processing():
+    """示例4: 批量处理"""
+    print("\n" + "=" * 60)
+    print("示例4: 批量处理")
+    print("=" * 60)
+    
+    # 创建测试查询文件
+    test_queries = [
+        "# 测试查询文件",
+        "贵州茅台 公告",
+        "中国平安 分红",
+        "宁德时代 业绩预告",
+        "",
+        "# 空行会被忽略",
+        "回购增持"
+    ]
+    
+    queries_file = "test_queries.txt"
+    with open(queries_file, 'w', encoding='utf-8') as f:
+        f.write("\n".join(test_queries))
+    
+    print(f"创建测试查询文件: {queries_file}")
+    
+    # 读取查询文件
+    queries = Utils.read_queries_from_file(queries_file)
+    print(f"读取到 {len(queries)} 个查询:")
+    for i, query in enumerate(queries, 1):
+        print(f"  {i}. {query}")
+    
+    # 清理测试文件
+    os.remove(queries_file)
+    print(f"已清理测试文件")
+
+def example_data_export():
+    """示例5: 数据导出"""
+    print("\n" + "=" * 60)
+    print("示例5: 数据导出")
+    print("=" * 60)
+    
+    # 创建测试数据
+    test_data = [
+        {
+            "title": "某某公司2023年度业绩预告",
+            "summary": "公司预计2023年度净利润同比增长50%-70%",
+            "url": "https://example.com/announcement/12345",
+            "publish_date": "2024-01-15 09:30:00"
+        },
+        {
+            "title": "另一家公司重大合同公告",
+            "summary": "公司与客户签订重大销售合同，金额约10亿元",
+            "url": "https://example.com/announcement/12346",
+            "publish_date": "2024-01-14 16:45:00"
+        }
+    ]
+    
+    # 导出为不同格式
+    formats = ["csv", "json", "txt"]
+    
+    for fmt in formats:
+        filename = f"test_output.{fmt}"
+        
+        if fmt == "csv":
+            success = Utils.save_to_csv(test_data, filename)
+        elif fmt == "json":
+            success = Utils.save_to_json(test_data, filename)
+        elif fmt == "txt":
+            success = Utils.save_to_txt(test_data, filename)
+        
+        if success:
+            print(f"✓ 数据已导出为 {fmt.upper()} 格式: {filename}")
+            
+            # 显示文件内容预览
+            try:
+                with open(filename, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                    print(f"  文件大小: {len(content)} 字节")
+                    
+                    # 清理测试文件
+                    os.remove(filename)
+            except:
+                pass
+        else:
+            print(f"✗ 导出为 {fmt.upper()} 格式失败")
+
+def example_error_handling():
+    """示例6: 错误处理"""
+    print("\n" + "=" * 60)
+    print("示例6: 错误处理")
+    print("=" * 60)
+    
+    search = AnnouncementSearch()
+    
+    # 测试无效查询
+    invalid_queries = [
+        "",  # 空查询
+        "a",  # 太短的查询
+        "   ",  # 只有空格的查询
+    ]
+    
+    for query in invalid_queries:
+        print(f"\n测试查询: '{query}'")
+        
+        if Utils.validate_query(query):
+            success, results, message = search.search(query)
+            print(f"  结果: {message}")
+        else:
+            print(f"  验证失败: 查询无效")
+
+def main():
+    """主函数"""
+    if not setup_environment():
+        print("环境设置失败，请检查配置")
+        return
+    
+    try:
+        example_basic_search()
+        example_multiple_queries()
+        example_smart_query_analysis()
+        example_batch_processing()
+        example_data_export()
+        example_error_handling()
+        
+        print("\n" + "=" * 60)
+        print("所有示例执行完成！")
+        print("=" * 60)
+        print("\n更多使用方式:")
+        print("1. 使用命令行: announcement-search --help")
+        print("2. 查看详细文档: 参考 README.md 和 SKILL.md")
+    except KeyboardInterrupt:
+        print("\n\n示例被用户中断")
+    except Exception as e:
+        print(f"\n发生错误: {e}")
+        import traceback
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    main()

Skills/announcement-search/scripts/requirements.txt

@@ -0,0 +1,10 @@
+requests>=2.28.0
+pandas>=1.5.0
+python-dotenv>=0.21.0
+argparse>=1.4.0
+logging>=0.4.9.6
+json>=2.0.9
+csv>=1.0
+datetime>=4.3
+os-sys>=2.0.1
+sys>=3.0.0

Skills/announcement-search/scripts/setup.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+from setuptools import setup, find_packages
+import os
+
+def read_file(filename):
+    with open(os.path.join(os.path.dirname(__file__), filename), 'r', encoding='utf-8') as f:
+        return f.read()
+
+def read_requirements():
+    requirements_file = os.path.join(os.path.dirname(__file__), 'requirements.txt')
+    if os.path.exists(requirements_file):
+        with open(requirements_file, 'r', encoding='utf-8') as f:
+            return [line.strip() for line in f if line.strip() and not line.startswith('#')]
+    return []
+
+setup(
+    name="announcement-search",
+    version="1.0.0",
+    description="金融公告搜索工具 - 搜索A股、港股、基金、ETF等金融标的公告",
+    long_description=read_file('../README.md'),
+    long_description_content_type="text/markdown",
+    author="公告搜索技能开发团队",
+    author_email="",
+    url="",
+    packages=find_packages(),
+    py_modules=[
+        'config',
+        'utils',
+        'announcement_search'
+    ],
+    scripts=['__main__.py'],
+    install_requires=read_requirements(),
+    entry_points={
+        'console_scripts': [
+            'announcement-search=__main__:main',
+        ],
+    },
+    classifiers=[
+        'Development Status :: 4 - Beta',
+        'Intended Audience :: Financial and Insurance Industry',
+        'Topic :: Office/Business :: Financial :: Investment',
+        'License :: OSI Approved :: MIT License',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
+    ],
+    keywords='finance, announcement, search, stock, fund, etf',
+    project_urls={
+        'Documentation': 'https://github.com/example/announcement-search',
+        'Source': 'https://github.com/example/announcement-search',
+        'Tracker': 'https://github.com/example/announcement-search/issues',
+    },
+    python_requires='>=3.7',
+    include_package_data=True,
+    zip_safe=False,
+)
+
+if __name__ == "__main__":
+    print("公告搜索工具安装脚本")
+    print("=" * 40)
+    print("安装方法:")
+    print("1. 基本安装: pip install -e .")
+    print("2. 开发安装: pip install -e .[dev]")
+    print("3. 生产安装: pip install .")
+    print()
+    print("安装后可以使用: announcement-search --help")

Skills/announcement-search/scripts/test_basic.py

@@ -0,0 +1,335 @@
+#!/usr/bin/env python3
+"""
+公告搜索工具基本测试
+"""
+
+import os
+import sys
+import unittest
+import tempfile
+import json
+from unittest.mock import patch, MagicMock
+
+# 添加当前目录到Python路径
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from config import Config
+from utils import Utils
+from announcement_search import AnnouncementSearch
+
+class TestConfig(unittest.TestCase):
+    def test_config_initialization(self):
+        """测试配置初始化"""
+        config = Config()
+        self.assertIsNotNone(config.config)
+        
+        # 检查基本配置项
+        self.assertIn("api", config.config)
+        self.assertIn("auth", config.config)
+        self.assertIn("search", config.config)
+    
+    def test_get_api_key(self):
+        """测试获取API Key"""
+        config = Config()
+        
+        # 测试环境变量中的API Key
+        with patch.dict(os.environ, {"IWENCAI_API_KEY": "test_key"}):
+            config = Config()
+            api_key = config.get_api_key()
+            self.assertEqual(api_key, "test_key")
+        
+        # 测试缺少API Key的情况
+        with patch.dict(os.environ, {}, clear=True):
+            config = Config()
+            with self.assertRaises(ValueError):
+                config.get_api_key()
+    
+    def test_validate_config(self):
+        """测试配置验证"""
+        config = Config()
+        
+        # 测试有效配置
+        with patch.dict(os.environ, {"IWENCAI_API_KEY": "valid_key"}):
+            config = Config()
+            self.assertTrue(config.validate())
+        
+        # 测试无效配置（缺少API Key）
+        with patch.dict(os.environ, {}, clear=True):
+            config = Config()
+            self.assertFalse(config.validate())
+
+class TestUtils(unittest.TestCase):
+    def test_validate_query(self):
+        """测试查询验证"""
+        # 有效查询
+        self.assertTrue(Utils.validate_query("贵州茅台"))
+        self.assertTrue(Utils.validate_query("上市公司业绩预告"))
+        
+        # 无效查询
+        self.assertFalse(Utils.validate_query(""))
+        self.assertFalse(Utils.validate_query("  "))
+        self.assertFalse(Utils.validate_query("a"))
+    
+    def test_generate_cache_key(self):
+        """测试缓存键生成"""
+        key1 = Utils.generate_cache_key("test query", 10)
+        key2 = Utils.generate_cache_key("test query", 10)
+        key3 = Utils.generate_cache_key("different query", 10)
+        
+        # 相同查询应生成相同键
+        self.assertEqual(key1, key2)
+        
+        # 不同查询应生成不同键
+        self.assertNotEqual(key1, key3)
+    
+    def test_save_to_csv(self):
+        """测试保存为CSV"""
+        test_data = [
+            {"title": "测试标题1", "summary": "测试摘要1", "url": "http://test1.com", "publish_date": "2024-01-01 10:00:00"},
+            {"title": "测试标题2", "summary": "测试摘要2", "url": "http://test2.com", "publish_date": "2024-01-02 11:00:00"}
+        ]
+        
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.csv', delete=False) as tmp:
+            tmp_path = tmp.name
+        
+        try:
+            success = Utils.save_to_csv(test_data, tmp_path)
+            self.assertTrue(success)
+            
+            # 验证文件内容
+            with open(tmp_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+                self.assertIn("测试标题1", content)
+                self.assertIn("测试标题2", content)
+                self.assertIn("title,summary,url,publish_date", content)
+        finally:
+            if os.path.exists(tmp_path):
+                os.remove(tmp_path)
+    
+    def test_save_to_json(self):
+        """测试保存为JSON"""
+        test_data = [
+            {"title": "测试标题", "summary": "测试摘要", "url": "http://test.com", "publish_date": "2024-01-01 10:00:00"}
+        ]
+        
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as tmp:
+            tmp_path = tmp.name
+        
+        try:
+            success = Utils.save_to_json(test_data, tmp_path)
+            self.assertTrue(success)
+            
+            # 验证文件内容
+            with open(tmp_path, 'r', encoding='utf-8') as f:
+                loaded_data = json.load(f)
+                self.assertEqual(len(loaded_data), 1)
+                self.assertEqual(loaded_data[0]["title"], "测试标题")
+        finally:
+            if os.path.exists(tmp_path):
+                os.remove(tmp_path)
+    
+    def test_read_queries_from_file(self):
+        """测试从文件读取查询"""
+        test_queries = [
+            "# 注释行",
+            "查询1",
+            "",
+            "查询2",
+            " 查询3 "  # 带空格的查询
+        ]
+        
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as tmp:
+            tmp.write("\n".join(test_queries))
+            tmp_path = tmp.name
+        
+        try:
+            queries = Utils.read_queries_from_file(tmp_path)
+            
+            # 应该读取3个查询（忽略注释行和空行）
+            self.assertEqual(len(queries), 3)
+            self.assertIn("查询1", queries)
+            self.assertIn("查询2", queries)
+            self.assertIn("查询3", queries)  # 空格应该被去除
+        finally:
+            if os.path.exists(tmp_path):
+                os.remove(tmp_path)
+    
+    def test_format_results_for_display(self):
+        """测试结果格式化显示"""
+        test_results = [
+            {"title": "测试标题1", "summary": "测试摘要1", "url": "http://test1.com", "publish_date": "2024-01-01 10:00:00"},
+            {"title": "测试标题2", "summary": "测试摘要2", "url": "http://test2.com", "publish_date": "2024-01-02 11:00:00"}
+        ]
+        
+        formatted = Utils.format_results_for_display(test_results)
+        
+        # 检查基本内容
+        self.assertIn("找到 2 条相关公告", formatted)
+        self.assertIn("测试标题1", formatted)
+        self.assertIn("测试标题2", formatted)
+        
+        # 测试空结果
+        empty_formatted = Utils.format_results_for_display([])
+        self.assertEqual(empty_formatted, "未找到相关公告信息。")
+
+class TestAnnouncementSearch(unittest.TestCase):
+    def setUp(self):
+        """测试前置设置"""
+        self.search = AnnouncementSearch()
+    
+    def test_smart_query_analysis(self):
+        """测试智能查询分析"""
+        # 测试简单查询
+        queries = self.search.smart_query_analysis("贵州茅台")
+        self.assertEqual(queries, ["贵州茅台"])
+        
+        # 测试包含"和"的查询
+        queries = self.search.smart_query_analysis("贵州茅台和五粮液")
+        self.assertIn("贵州茅台 公告", queries)
+        self.assertIn("五粮液 公告", queries)
+        
+        # 测试包含"与"的查询
+        queries = self.search.smart_query_analysis("宁德时代与比亚迪")
+        self.assertIn("宁德时代 公告", queries)
+        self.assertIn("比亚迪 公告", queries)
+        
+        # 测试包含"、"的查询
+        queries = self.search.smart_query_analysis("中国平安、中国人寿")
+        self.assertIn("中国平安 公告", queries)
+        self.assertIn("中国人寿 公告", queries)
+    
+    def test_evaluate_results(self):
+        """测试结果评估"""
+        test_results = [
+            {"title": "贵州茅台2023年度业绩预告", "summary": "公司预计2023年度净利润增长"},
+            {"title": "五粮液分红公告", "summary": "公司宣布年度分红方案"},
+            {"title": "无关公告", "summary": "其他内容"}
+        ]
+        
+        # 测试高相关性
+        relevant, evaluation = self.search.evaluate_results("贵州茅台 业绩预告", test_results)
+        self.assertTrue(relevant)
+        self.assertIn("较高", evaluation)
+        
+        # 测试低相关性
+        relevant, evaluation = self.search.evaluate_results("完全无关的查询", test_results)
+        self.assertFalse(relevant)
+        self.assertIn("较低", evaluation)
+    
+    def test_generate_search_summary(self):
+        """测试搜索摘要生成"""
+        test_results = [
+            {"title": "标题1", "summary": "摘要1", "url": "http://test1.com", "publish_date": "2024-01-01 10:00:00"},
+            {"title": "标题2", "summary": "摘要2", "url": "http://test2.com", "publish_date": "2024-01-02 11:00:00"},
+            {"title": "标题3", "summary": "摘要3", "url": "http://test3.com", "publish_date": "2024-01-03 12:00:00"},
+            {"title": "标题4", "summary": "摘要4", "url": "http://test4.com", "publish_date": "2024-01-04 13:00:00"},
+            {"title": "标题5", "summary": "摘要5", "url": "http://test5.com", "publish_date": "2024-01-05 14:00:00"},
+            {"title": "标题6", "summary": "摘要6", "url": "http://test6.com", "publish_date": "2024-01-06 15:00:00"}
+        ]
+        
+        summary = self.search.generate_search_summary("测试查询", test_results)
+        
+        # 检查基本内容
+        self.assertIn("测试查询", summary)
+        self.assertIn("找到 6 条相关公告", summary)
+        self.assertIn("标题1", summary)
+        self.assertIn("标题5", summary)
+        self.assertIn("还有 1 条结果", summary)  # 只显示前5条
+        
+        # 测试空结果
+        empty_summary = self.search.generate_search_summary("空查询", [])
+        self.assertIn("未找到相关公告信息", empty_summary)
+    
+    @patch('announcement_search.requests.post')
+    def test_search_success(self, mock_post):
+        """测试成功搜索"""
+        # 模拟API响应
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "data": [
+                {"title": "测试公告1", "summary": "测试摘要1", "url": "http://test1.com", "publish_date": "2024-01-01 10:00:00"},
+                {"title": "测试公告2", "summary": "测试摘要2", "url": "http://test2.com", "publish_date": "2024-01-02 11:00:00"}
+            ]
+        }
+        mock_post.return_value = mock_response
+        
+        success, results, message = self.search.search("测试查询", limit=2)
+        
+        self.assertTrue(success)
+        self.assertEqual(len(results), 2)
+        self.assertEqual(message, "搜索成功")
+        self.assertEqual(results[0]["title"], "测试公告1")
+        self.assertEqual(results[1]["title"], "测试公告2")
+    
+    @patch('announcement_search.requests.post')
+    def test_search_empty_results(self, mock_post):
+        """测试空结果搜索"""
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {"data": []}
+        mock_post.return_value = mock_response
+        
+        success, results, message = self.search.search("测试查询")
+        
+        self.assertTrue(success)
+        self.assertEqual(len(results), 0)
+        self.assertEqual(message, "未找到相关公告")
+    
+    @patch('announcement_search.requests.post')
+    def test_search_auth_failure(self, mock_post):
+        """测试认证失败"""
+        mock_response = MagicMock()
+        mock_response.status_code = 401
+        mock_post.return_value = mock_response
+        
+        success, results, message = self.search.search("测试查询")
+        
+        self.assertFalse(success)
+        self.assertEqual(len(results), 0)
+        self.assertIn("API认证失败", message)
+    
+    @patch('announcement_search.requests.post')
+    def test_search_network_error(self, mock_post):
+        """测试网络错误"""
+        mock_post.side_effect = ConnectionError("网络连接错误")
+        
+        success, results, message = self.search.search("测试查询")
+        
+        self.assertFalse(success)
+        self.assertEqual(len(results), 0)
+        self.assertIn("网络连接错误", message)
+
+def run_tests():
+    """运行所有测试"""
+    print("运行公告搜索工具测试...")
+    print("=" * 60)
+    
+    # 创建测试套件
+    loader = unittest.TestLoader()
+    suite = unittest.TestSuite()
+    
+    # 添加测试类
+    suite.addTests(loader.loadTestsFromTestCase(TestConfig))
+    suite.addTests(loader.loadTestsFromTestCase(TestUtils))
+    suite.addTests(loader.loadTestsFromTestCase(TestAnnouncementSearch))
+    
+    # 运行测试
+    runner = unittest.TextTestRunner(verbosity=2)
+    result = runner.run(suite)
+    
+    print("=" * 60)
+    print(f"测试完成: {result.testsRun} 个测试用例")
+    print(f"通过: {result.testsRun - len(result.failures) - len(result.errors)}")
+    print(f"失败: {len(result.failures)}")
+    print(f"错误: {len(result.errors)}")
+    
+    return result.wasSuccessful()
+
+if __name__ == "__main__":
+    # 设置环境变量用于测试
+    os.environ["IWENCAI_API_KEY"] = "test_key_for_unit_tests"
+    os.environ["LOG_LEVEL"] = "ERROR"  # 测试时减少日志输出
+    
+    success = run_tests()
+    sys.exit(0 if success else 1)

Skills/announcement-search/scripts/test_queries.txt

@@ -0,0 +1,52 @@
+# 公告搜索测试查询文件
+# 每行一个查询，空行和以#开头的行会被忽略
+
+# 1. 公司公告查询
+贵州茅台 公告
+中国平安 最新公告
+宁德时代 业绩预告
+
+# 2. 公告类型查询
+分红派息公告
+回购增持公告
+资产重组公告
+
+# 3. 定期报告查询
+上市公司年报
+2023年年度报告
+第一季度报告
+
+# 4. 综合查询
+重大合同公告
+业绩快报
+权益变动公告
+
+# 5. 行业公告查询
+银行股 公告
+券商 最新公告
+保险行业 公告
+
+# 6. 事件驱动查询
+限售股解禁
+股东减持
+股权激励
+
+# 7. 市场热点查询
+注册制相关公告
+北交所 公告
+科创板 业绩预告
+
+# 8. 基金公告查询
+基金分红公告
+ETF 公告
+公募基金 最新公告
+
+# 9. 港股公告查询
+港股通 公告
+H股 最新公告
+红筹股 公告
+
+# 10. 综合金融查询
+债券发行公告
+可转债 公告
+资产证券化 公告

Skills/announcement-search/scripts/utils.py

@@ -0,0 +1,206 @@
+import os
+import sys
+import json
+import csv
+import logging
+import hashlib
+import time
+from datetime import datetime
+from typing import Dict, List, Any, Optional, Union
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+class Utils:
+    @staticmethod
+    def setup_logging(level: str = "INFO"):
+        log_level = getattr(logging, level.upper(), logging.INFO)
+        logging.basicConfig(
+            level=log_level,
+            format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            handlers=[
+                logging.StreamHandler(sys.stdout)
+            ]
+        )
+    
+    @staticmethod
+    def validate_query(query: str) -> bool:
+        if not query or not query.strip():
+            logger.error("Query cannot be empty")
+            return False
+        
+        if len(query.strip()) < 2:
+            logger.error("Query is too short")
+            return False
+        
+        return True
+    
+    @staticmethod
+    def parse_date(date_str: str, format_str: str = "%Y-%m-%d %H:%M:%S") -> Optional[datetime]:
+        try:
+            return datetime.strptime(date_str, format_str)
+        except ValueError:
+            logger.warning(f"Failed to parse date: {date_str}")
+            return None
+    
+    @staticmethod
+    def format_date(date_obj: datetime, format_str: str = "%Y-%m-%d %H:%M:%S") -> str:
+        return date_obj.strftime(format_str)
+    
+    @staticmethod
+    def generate_cache_key(query: str, limit: int = 10) -> str:
+        key_str = f"{query}_{limit}"
+        return hashlib.md5(key_str.encode()).hexdigest()
+    
+    @staticmethod
+    def save_to_csv(data: List[Dict[str, Any]], filepath: str) -> bool:
+        try:
+            if not data:
+                logger.warning("No data to save")
+                return False
+            
+            os.makedirs(os.path.dirname(filepath), exist_ok=True)
+            
+            fieldnames = data[0].keys()
+            with open(filepath, 'w', newline='', encoding='utf-8') as csvfile:
+                writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+                writer.writeheader()
+                writer.writerows(data)
+            
+            logger.info(f"Data saved to CSV: {filepath}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to save CSV: {e}")
+            return False
+    
+    @staticmethod
+    def save_to_json(data: List[Dict[str, Any]], filepath: str) -> bool:
+        try:
+            if not data:
+                logger.warning("No data to save")
+                return False
+            
+            os.makedirs(os.path.dirname(filepath), exist_ok=True)
+            
+            with open(filepath, 'w', encoding='utf-8') as jsonfile:
+                json.dump(data, jsonfile, ensure_ascii=False, indent=2)
+            
+            logger.info(f"Data saved to JSON: {filepath}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to save JSON: {e}")
+            return False
+    
+    @staticmethod
+    def save_to_txt(data: List[Dict[str, Any]], filepath: str) -> bool:
+        try:
+            if not data:
+                logger.warning("No data to save")
+                return False
+            
+            os.makedirs(os.path.dirname(filepath), exist_ok=True)
+            
+            with open(filepath, 'w', encoding='utf-8') as txtfile:
+                for i, item in enumerate(data, 1):
+                    txtfile.write(f"结果 {i}:\n")
+                    txtfile.write(f"标题: {item.get('title', '')}\n")
+                    txtfile.write(f"摘要: {item.get('summary', '')}\n")
+                    txtfile.write(f"链接: {item.get('url', '')}\n")
+                    txtfile.write(f"发布时间: {item.get('publish_date', '')}\n")
+                    txtfile.write("-" * 50 + "\n\n")
+            
+            logger.info(f"Data saved to TXT: {filepath}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to save TXT: {e}")
+            return False
+    
+    @staticmethod
+    def read_queries_from_file(filepath: str) -> List[str]:
+        try:
+            if not os.path.exists(filepath):
+                logger.error(f"Input file not found: {filepath}")
+                return []
+            
+            queries = []
+            with open(filepath, 'r', encoding='utf-8') as f:
+                for line in f:
+                    line = line.strip()
+                    if line and not line.startswith('#'):
+                        queries.append(line)
+            
+            logger.info(f"Read {len(queries)} queries from {filepath}")
+            return queries
+        except Exception as e:
+            logger.error(f"Failed to read queries from file: {e}")
+            return []
+    
+    @staticmethod
+    def ensure_directory(directory: str) -> bool:
+        try:
+            Path(directory).mkdir(parents=True, exist_ok=True)
+            return True
+        except Exception as e:
+            logger.error(f"Failed to create directory {directory}: {e}")
+            return False
+    
+    @staticmethod
+    def get_file_extension(filepath: str) -> str:
+        return os.path.splitext(filepath)[1].lower().lstrip('.')
+    
+    @staticmethod
+    def format_results_for_display(results: List[Dict[str, Any]]) -> str:
+        if not results:
+            return "未找到相关公告信息。"
+        
+        output_lines = []
+        output_lines.append(f"找到 {len(results)} 条相关公告：")
+        output_lines.append("=" * 60)
+        
+        for i, result in enumerate(results, 1):
+            output_lines.append(f"{i}. {result.get('title', '')}")
+            output_lines.append(f"   摘要: {result.get('summary', '')}")
+            output_lines.append(f"   发布时间: {result.get('publish_date', '')}")
+            output_lines.append(f"   链接: {result.get('url', '')}")
+            output_lines.append("-" * 40)
+
+        return "\n".join(output_lines)
+    
+    @staticmethod
+    def calculate_execution_time(start_time: float) -> float:
+        return time.time() - start_time
+    
+    @staticmethod
+    def format_execution_time(seconds: float) -> str:
+        if seconds < 1:
+            return f"{seconds*1000:.0f}毫秒"
+        elif seconds < 60:
+            return f"{seconds:.1f}秒"
+        else:
+            minutes = seconds / 60
+            return f"{minutes:.1f}分钟"
+
+if __name__ == "__main__":
+    Utils.setup_logging()
+    logger.info("Utils module loaded successfully")
+    
+    test_data = [
+        {
+            "title": "测试公告标题",
+            "summary": "测试公告摘要",
+            "url": "https://example.com/test",
+            "publish_date": "2024-01-01 10:00:00"
+        }
+    ]
+    
+    print("Testing CSV save:")
+    Utils.save_to_csv(test_data, "test_output.csv")
+    
+    print("\nTesting JSON save:")
+    Utils.save_to_json(test_data, "test_output.json")
+    
+    print("\nTesting TXT save:")
+    Utils.save_to_txt(test_data, "test_output.txt")
+    
+    print("\nTesting display formatting:")
+    print(Utils.format_results_for_display(test_data))

Skills/financial-query/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Skills/financial-query/SKILL.md

@@ -0,0 +1,224 @@
+---
+name: financial-query
+displayName: 金融数据查询
+description: 金融结构化数据统一查询入口。通过同花顺问财 OpenAPI `query2data` 端点，用自然语言查询A股、指数、港股、美股、基金、ETF、期货、宏观、可转债等全市场金融结构化数据，支持行情指标、技术形态、财务指标、行业概念等多条件组合筛选标的，同时支持事件数据、经营数据、财务数据等查询。新闻/公告/研报全文等纯文本类查询走 `news-search` / `announcement-search` / `report-search`这几个SKill。
+license: Complete terms in LICENSE.txt
+---
+
+# 金融数据查询 使用指南
+
+## 版本
+
+`2.0.0`（与 `X-Claw-Skill-Version` 保持一致）。本地 `name` 为 `financial-query`；同花顺问财平台上的注册名（`X-Claw-Skill-Id`）仍为 `hithink-financial-query`，API 调用必须沿用注册名。
+
+## 技能概述
+
+本 skill 是**金融结构化数据查询的统一入口**，通过调用同花顺问财 OpenAPI 的 `query2data` 端点，用一句自然语言就能拿到 A 股 / 港股 / 美股 / 基金 / 期货 / ETF / 板块 / 概念 / 指数 等全市场的结构化数据。
+
+**覆盖标的（标的种类，不限于此）：**
+
+- **股票**：A 股、港股、美股
+- **基金**：公募基金、ETF、LOF、指数基金
+- **指数**：宽基指数、行业指数、概念指数
+- **期货 / 债券 / 可转债**
+- **板块 / 概念 / 行业 / 地域**：成分、资金、涨跌
+- **宏观经济**：GDP、CPI、PMI、社融、LPR
+
+**支持查询的指标维度（不限于此）：**
+
+- **行情**：最新价、涨跌幅、成交量、成交额、换手率、市值、振幅
+- **估值**：PE、PB、PS、PEG、股息率、估值分位
+- **财务**：营收、净利润、ROE、毛利率、负债率、现金流、EPS、研发投入
+- **事件**：业绩预告、分红、回购、增持、解禁、龙虎榜、大宗交易、调研
+- **资金**：主力资金净流入、北向资金、融资融券
+- **指数 / 板块数据**：指数点位、成分股、板块涨跌
+
+
+## 使用前
+
+> **首次使用 - 获取 API Key**
+> 所有技能都需要 `IWENCAI_API_KEY` 环境变量。如果用户尚未配置，按以下步骤引导：
+>
+> **步骤 1**：打开同花顺 i 问财 SkillHub → `https://www.iwencai.com/skillhub`
+>
+> **步骤 2**：登录
+>
+> **步骤 3**：点击具体的 Skill，在弹窗的"安装方式 → Agent 用户"中复制 `IWENCAI_API_KEY`
+>
+> **步骤 4**：配置环境变量
+>
+> ```bash
+> # macOS / Linux
+> export IWENCAI_API_KEY="your-api-key"
+>
+> # PowerShell
+> $env:IWENCAI_API_KEY = "your-api-key"
+> ```
+
+## 核心处理流程
+
+### 步骤 1: 接收用户 Query
+
+接收自然语言请求，识别**标的（股票/基金/指数/板块/期货/债券）**、**指标（行情/财务/估值/事件）**、**时间范围**。
+
+> **注意：本 skill 不做"筛选/选股/TopN/排名"**——若用户问的是"前 N 名 / 满足条件的所有标的 / 帮我选股"等，请改交给 `hithink-astock-selector` 等专用选股 skill。
+
+### 步骤 2: Query 改写
+
+将口语化问句改写为标准问财查询问句，**保持原意不变**：
+
+- `"贵州茅台现在多少钱"` → `"贵州茅台 最新价"`
+- `"贵州茅台的 PE 是多少"` → `"贵州茅台 PE(TTM)"`
+- `"中证 500 指数当前点位"` → `"中证 500 指数 最新点位"`
+- `"比亚迪最近的销量"` → `"比亚迪 月度销量"`
+- `"宁德时代去年营收"` → `"宁德时代 2024 营业收入"`
+
+**思维链拆解（按需）：**
+- 单次查询：能一句话答的，直接发
+- 多次查询：需要多角度数据的，拆成 2-4 个独立 query 并行调用
+
+### 步骤 3: API 调用
+
+调用同花顺问财 OpenAPI 网关的 `query2data` 端点，使用 `scripts/cli.py` CLI 或直接构造 HTTP 请求。**所有请求必须严格携带 8 个 Header**：
+
+| Header | 取值说明 |
+|--------|----------|
+| `Authorization` | `Bearer <IWENCAI_API_KEY>` |
+| `Content-Type` | `application/json` |
+| `X-Claw-Call-Type` | `normal`（正常请求）/ `retry`（失败重试） |
+| `X-Claw-Skill-Id` | **`hithink-financial-query`** |
+| `X-Claw-Skill-Version` | **`2.0.0`** |
+| `X-Claw-Plugin-Id` | `none` |
+| `X-Claw-Plugin-Version` | `none` |
+| `X-Claw-Trace-Id` | 64 字符 hex（`secrets.token_hex(32)`） |
+
+**请求体：**
+```json
+{
+  "query": "改写后的查询语句",
+  "page": "1",
+  "limit": "100",
+  "is_cache": "1",
+  "expand_index": "true"
+}
+```
+
+**Python 调用示例：**
+```python
+import os, json, secrets, urllib.request
+
+url = "https://openapi.iwencai.com/v1/query2data"
+api_key = os.environ["IWENCAI_API_KEY"]
+trace_id = secrets.token_hex(32)
+
+payload = {
+    "query": "贵州茅台 最新价",
+    "page": "1", "limit": "100",
+    "is_cache": "1", "expand_index": "true",
+}
+headers = {
+    "Authorization": f"Bearer {api_key}",
+    "Content-Type": "application/json",
+    "X-Claw-Call-Type": "normal",
+    "X-Claw-Skill-Id": "hithink-financial-query",
+    "X-Claw-Skill-Version": "2.0.0",
+    "X-Claw-Plugin-Id": "none",
+    "X-Claw-Plugin-Version": "none",
+    "X-Claw-Trace-Id": trace_id,
+}
+req = urllib.request.Request(url, data=json.dumps(payload).encode("utf-8"),
+                              headers=headers, method="POST")
+resp = urllib.request.urlopen(req, timeout=30)
+result = json.loads(resp.read().decode("utf-8"))
+
+datas = result.get("datas", [])
+code_count = result.get("code_count", 0)
+```
+
+### 步骤 4: 空数据处理
+
+`datas` 为空时**最多重试 2 次**逐步放宽：
+
+- 首次重试：去掉最苛刻的次要条件
+- 二次重试：用更通用表述（如"贵州茅台"代替"600519.SH 贵州茅台"）
+
+每次重试把 `X-Claw-Call-Type` 改为 `retry`。
+
+### 步骤 5: 数据解析
+
+`datas` 是对象数组，列名随查询变化（中文 key，如"股票代码 / 股票简称 / 最新价 / 涨跌幅 / 市值 / PE / 主营行业"等）。`code_count` 是符合条件的总条数（> `len(datas)` 时需翻页）。
+
+## 请求参数
+
+| 参数名 | 类型 | 必填 | 说明 |
+|--------|------|------|------|
+| `query` | string | 是 | 用户/改写后的查询问句（中文自然语言） |
+| `page` | string | 否 | 分页页码，默认 `1` |
+| `limit` | string | 否 | 每页条数，默认 `100`（最高 500） |
+| `is_cache` | string | 否 | 是否走缓存，默认 `1` |
+| `expand_index` | string | 否 | 是否展开指数，默认 `true` |
+
+## 响应参数
+
+| 参数名 | 类型 | 说明 |
+|--------|------|------|
+| `datas` | array | 金融数据对象数组，列名随 query 变化 |
+| `code_count` | int | 符合查询条件的总条数（可能 > `len(datas)`） |
+| `chunks_info` | object | 查询字句信息（解析后的条件） |
+| `status_code` | int | `0` = 成功；非 0 = 错误（见错误码） |
+
+## CLI 使用
+
+`scripts/cli.py` 提供跨平台命令行入口。
+
+```bash
+python3 scripts/cli.py --query "贵州茅台 最新价"
+python3 scripts/cli.py --query "今日涨停 行业=科技" --page 1 --limit 50
+python3 scripts/cli.py --query "银行 股息率前10" --timeout 60
+```
+
+**参数：**
+- `--query` 必填
+- `--page` 默认 1
+- `--limit` 默认 10
+- `--api-key` 可选（默认从 env 读）
+- `--call-type` 默认 `normal`
+- `--timeout` 默认 30
+
+## 错误码
+
+| 状态码 | 含义 | 建议 |
+|---|---|---|
+| `-2326 / -2126 / -1325` | 统计量过大或超时 | 缩小时间范围 / 减少指标 / 收窄标的 |
+| `-2331 / -1330 / -2309` | 数据库查询超时 | 稍后重试 |
+| `-2322 / -2321 / -1321` | 指标不存在 | 调整指标表达 |
+| `-225` | 当前周期表无此指标 | 调整周期或口径 |
+
+## 与其他 skill 的边界
+
+| 问句 | 用 `financial-query` (本) | 用专门 skill |
+|---|---|---|
+| "贵州茅台最新价" | ✅ | — |
+| "贵州茅台的 PE / 营收 / ROE" | ✅ | — |
+| "中证 500 指数当前点位" | ✅ | — |
+| "比亚迪上个月销量" | ✅ | — |
+| "宁德时代 最近新闻全文" | ❌ | `news-search` |
+| "宁德时代 最近公告" | ❌（除非只要摘要数字） | `announcement-search` |
+| "宁德时代 最新研报" | ❌（除非只要研报评级汇总） | `report-search` |
+
+
+**简单规则：**
+- 问的是**"某个标的的某个数字/字段是多少"** → 本 skill
+- 问的是**"符合某条件的所有标的 / 排名 / TopN / 选股"** → 专用选股 skill
+- 问的是**"全文/原文/URL"** → 专门检索 skill
+- 问的是**"执行操作"（模拟交易）** → `simulated-trading`
+
+## 代码结构
+
+```
+financial-query/
+├── SKILL.md          # 本文件
+├── LICENSE.txt       # 许可证
+└── scripts/
+    └── cli.py        # CLI 入口（封装 8 个 Header + 重试 + 解析）
+```

Skills/financial-query/scripts/cli.py

@@ -0,0 +1,300 @@
+#!/usr/bin/env python3
+"""
+金融结构化数据查询 - 通用金融数据查询工具（financial-query）
+
+通过同花顺问财 OpenAPI `query2data` 端点，查询 A 股 / 港股 / 美股 / 基金 /
+期货 / ETF / 板块 / 概念 / 指数 等全市场金融结构化数据（行情、估值、财务、
+事件、资金流向、宏观经济等）。
+
+严格遵循 Iwencai (问财) OpenAPI 网关规范：
+- 每次请求携带 8 个 X-Claw-* Header（X-Claw-Skill-Id 沿用平台注册名 `hithink-financial-query`）
+- X-Claw-Trace-Id 为每次新生成的 64 字符十六进制唯一 ID
+- Authorization Bearer 仅从环境变量 IWENCAI_API_KEY 读取
+- 优先使用 POST
+- 使用 Python3 标准库，跨平台兼容
+
+注意：默认返回 10 条数据，可通过 --page 和 --limit 参数翻页获取更多数据
+"""
+
+import argparse
+import json
+import os
+import secrets
+import sys
+import urllib.error
+import urllib.request
+from typing import Optional, Union
+
+SKILL_NAME = "hithink-financial-query"
+SKILL_VERSION = "2.0.0"
+DEFAULT_API_URL = "https://openapi.iwencai.com/v1/query2data"
+DEFAULT_PAGE = "1"
+DEFAULT_LIMIT = "10"
+DEFAULT_TIMEOUT = 30
+
+class AStockAPIError(Exception):
+    """API 错误异常类"""
+    def __init__(self, message: str, status_code: int = None, response: Union[str, dict, None] = None):
+        super().__init__(message)
+        self.message = message
+        self.status_code = status_code
+        self.response = response
+
+def generate_trace_id() -> str:
+    """生成 64 字符十六进制全局唯一追踪 ID。"""
+    return secrets.token_hex(32)
+
+def get_api_key(cli_api_key: Optional[str]) -> str:
+    """获取 API 密钥：优先 CLI 参数，其次环境变量。"""
+    key = cli_api_key or os.environ.get("IWENCAI_API_KEY", "")
+    if not key:
+        raise AStockAPIError(
+            "API 密钥未设置。请通过 --api-key 参数或环境变量 IWENCAI_API_KEY 指定。\n"
+            "首次使用获取指引：打开 https://www.iwencai.com/skillhub → 登录 → 点击 Skill → "
+            "安装方式-Agent用户-复制您的 IWENCAI_API_KEY。"
+        )
+    return key
+
+def build_headers(api_key: str, trace_id: str, call_type: str = "normal") -> dict:
+    """构造符合问财网关规范的请求头。"""
+    return {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+        "X-Claw-Call-Type": call_type,
+        "X-Claw-Skill-Id": SKILL_NAME,
+        "X-Claw-Skill-Version": SKILL_VERSION,
+        "X-Claw-Plugin-Id": "none",
+        "X-Claw-Plugin-Version": "none",
+        "X-Claw-Trace-Id": trace_id,
+    }
+
+def query_astock(
+    query: str,
+    page: str,
+    limit: str,
+    api_key: Optional[str],
+    call_type: str = "normal",
+    timeout: int = DEFAULT_TIMEOUT,
+) -> dict:
+    """
+    调用数据查询接口。
+    """
+    api_key = get_api_key(api_key)
+    api_url = DEFAULT_API_URL
+    trace_id = generate_trace_id()
+
+    payload = {
+        "query": query,
+        "page": page,
+        "limit": limit,
+        "is_cache": "1",
+        "expand_index": "true",
+    }
+
+    headers = build_headers(api_key, trace_id, call_type)
+    claw_headers = {k: v for k, v in headers.items() if k.startswith("X-Claw-")}
+    request = urllib.request.Request(
+        api_url,
+        data=json.dumps(payload).encode("utf-8"),
+        headers=headers,
+        method="POST",
+    )
+
+    try:
+        with urllib.request.urlopen(request, timeout=timeout) as response:
+            response_body = response.read().decode("utf-8")
+            
+            if not response_body.strip():
+                return {"text_response": "", "trace_id": trace_id, "claw_headers": claw_headers}
+            
+            try:
+                parsed_response = json.loads(response_body)
+                if isinstance(parsed_response, dict):
+                    parsed_response["trace_id"] = trace_id
+                    parsed_response["claw_headers"] = claw_headers
+                    return parsed_response
+                elif isinstance(parsed_response, list):
+                    return {"data": parsed_response, "trace_id": trace_id, "claw_headers": claw_headers}
+                else:
+                    return {"text_response": str(parsed_response), "trace_id": trace_id, "claw_headers": claw_headers}
+            except json.JSONDecodeError:
+                return {"text_response": response_body, "trace_id": trace_id, "claw_headers": claw_headers}
+
+    except urllib.error.HTTPError as e:
+        error_body = e.read().decode("utf-8") if e.fp else ""
+        
+        if error_body.strip():
+            try:
+                error_json = json.loads(error_body)
+                raise AStockAPIError(
+                    f"HTTP 错误 {e.code}: {e.reason}",
+                    status_code=e.code,
+                    response=error_json,
+                )
+            except json.JSONDecodeError:
+                raise AStockAPIError(
+                    f"HTTP 错误 {e.code}: {e.reason}",
+                    status_code=e.code,
+                    response=error_body,
+                )
+        else:
+            raise AStockAPIError(
+                f"HTTP 错误 {e.code}: {e.reason}",
+                status_code=e.code,
+                response="",
+            )
+    except urllib.error.URLError as e:
+        raise AStockAPIError(f"网络错误: {e.reason}")
+
+def parse_args():
+    """解析命令行参数"""
+    parser = argparse.ArgumentParser(
+        description="金融结构化数据查询 - 通用金融数据查询工具（不包含选股/筛选）",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    parser.add_argument(
+        "--query", "-q",
+        type=str,
+        required=True,
+        help="查询字符串（必填）"
+    )
+
+    parser.add_argument(
+        "--page",
+        type=str,
+        default=DEFAULT_PAGE,
+        help=f"分页参数，值必须为正整数（默认: {DEFAULT_PAGE}）"
+    )
+
+    parser.add_argument(
+        "--limit",
+        type=str,
+        default=DEFAULT_LIMIT,
+        help=f"每页条数，值必须为正整数（默认: {DEFAULT_LIMIT}）"
+    )
+
+    parser.add_argument(
+        "--api-key",
+        type=str,
+        default=None,
+        help="API 密钥（默认从环境变量 IWENCAI_API_KEY 读取）"
+    )
+
+    parser.add_argument(
+        "--call-type",
+        type=str,
+        choices=["normal", "retry"],
+        default="normal",
+        help="调用类型: normal（正常请求）或 retry（重试请求）（默认: normal）"
+    )
+
+    parser.add_argument(
+        "--timeout",
+        type=int,
+        default=DEFAULT_TIMEOUT,
+        help=f"请求超时时间，单位秒（默认: {DEFAULT_TIMEOUT}）"
+    )
+
+    args = parser.parse_args()
+
+    try:
+        page_val = int(args.page)
+        if page_val < 1:
+            parser.error(f"--page 必须为正整数，当前值: {args.page}")
+    except ValueError:
+        parser.error(f"--page 必须为正整数，当前值: {args.page}")
+
+    try:
+        limit_val = int(args.limit)
+        if limit_val < 1:
+            parser.error(f"--limit 必须为正整数，当前值: {args.limit}")
+    except ValueError:
+        parser.error(f"--limit 必须为正整数，当前值: {args.limit}")
+
+    return args
+
+def main():
+    """主函数"""
+    args = parse_args()
+
+    try:
+        result = query_astock(
+            query=args.query,
+            page=args.page,
+            limit=args.limit,
+            api_key=args.api_key,
+            call_type=args.call_type,
+            timeout=args.timeout,
+        )
+
+        if isinstance(result, dict) and "text_response" not in result:
+            if "datas" not in result:
+                print(json.dumps(result, ensure_ascii=False, indent=2))
+                sys.exit(1)
+
+            datas = result["datas"]
+            code_count = int(result.get("code_count", 0))
+            chunks_info = result.get("chunks_info", {})
+            trace_id = result.get("trace_id", "")
+
+            current_page = int(args.page)
+            current_limit = int(args.limit)
+            has_more = current_page * current_limit < code_count
+
+            output = {
+                "success": True,
+                "query": args.query,
+                "code_count": code_count,
+                "returned_count": len(datas),
+                "page": args.page,
+                "limit": args.limit,
+                "has_more": has_more,
+                "chunks_info": chunks_info,
+                "trace_id": trace_id,
+                "datas": datas,
+            }
+
+            if has_more:
+                output["pagination_tip"] = (
+                    f"共查到 {code_count} 条记录，当前返回第 {args.page} 页的 {len(datas)} 条。"
+                    f"如需更多数据，请使用 --page 参数翻页。"
+                )
+
+            if not datas:
+                output["empty_data_tip"] = (
+                    "未查询到符合条件的数据。建议放宽或简化查询条件后重试"
+                    "（使用 --call-type retry 标记重试请求）。"
+                    "如仍无数据，可引导用户访问同花顺问财: https://www.iwencai.com/unifiedwap/chat"
+                )
+
+            print(json.dumps(output, ensure_ascii=False, indent=2))
+        else:
+            print(json.dumps(result, ensure_ascii=False, indent=2))
+
+    except AStockAPIError as e:
+        if isinstance(e.response, dict):
+            gateway_output = dict(e.response)
+            if e.status_code is not None:
+                gateway_output.setdefault("status_code", e.status_code)
+            print(json.dumps(gateway_output, ensure_ascii=False, indent=2))
+        elif isinstance(e.response, str) and e.response.strip():
+            print(e.response)
+        else:
+            error_output = {"error": e.message}
+            if e.status_code is not None:
+                error_output["status_code"] = e.status_code
+            print(json.dumps(error_output, ensure_ascii=False, indent=2))
+        sys.exit(1)
+    except KeyboardInterrupt:
+        print("\n操作已取消。", file=sys.stderr)
+        sys.exit(130)
+    except Exception as e:
+        error_output = {
+            "error": f"发生错误: {str(e)}"
+        }
+        print(json.dumps(error_output, ensure_ascii=False, indent=2))
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

Skills/news-search/README.md

@@ -0,0 +1,277 @@
+# 新闻搜索技能
+
+财经领域资讯搜索引擎，调用同花顺问财的财经资讯搜索接口。
+
+## 功能特点
+
+- **财经资讯搜索**: 搜索各类财经新闻和资讯
+- **多关键词处理**: 自动拆解复杂查询为多个简单查询
+- **结果过滤**: 按时间、相关性等条件过滤结果
+- **数据导出**: 支持将搜索结果导出为CSV、JSON等格式
+- **批量处理**: 支持从文件读取多个查询并批量处理
+- **错误处理**: 完善的错误处理和重试机制
+- **日志记录**: 详细的运行日志和调试信息
+
+## 安装要求
+
+- Python 3.7+
+- requests库
+
+## 快速开始
+
+### 1. 设置API密钥
+
+```bash
+# 设置环境变量
+export IWENCAI_API_KEY="your_api_key_here"
+```
+
+### 2. 基本使用
+
+```bash
+# 搜索财经新闻
+python news_search.py -q "人工智能"
+
+# 搜索最近7天的新闻
+python news_search.py -q "芯片行业" -d 7
+
+# 限制返回结果数量
+python news_search.py -q "新能源汽车" -l 5
+
+# 导出为CSV格式
+python news_search.py -q "人工智能" -o results.csv -f csv
+
+# 导出为JSON格式
+python news_search.py -q "人工智能" -o results.json -f json
+```
+
+### 3. 批量处理
+
+```bash
+# 创建查询文件
+echo "人工智能" > queries.txt
+echo "芯片行业" >> queries.txt
+echo "新能源汽车" >> queries.txt
+
+# 批量处理并导出到目录
+python news_search.py -i queries.txt -o output/ -f csv
+
+# 批量处理并合并到一个文件
+python news_search.py -i queries.txt -o all_results.csv -f csv
+```
+
+### 4. 管道操作
+
+```bash
+# 从管道读取查询
+echo "人工智能" | python news_search.py
+
+# 从文件读取并管道处理
+cat queries.txt | xargs -I {} python news_search.py -q "{}"
+```
+
+## 命令行参数
+
+```
+usage: news_search.py [-h] (-q QUERY | -i INPUT) [-o OUTPUT] [-f {csv,json,text}] [-l LIMIT] [-d DAYS] [--api-key API_KEY] [--debug]
+
+财经新闻搜索工具 - 调用同花顺问财的财经资讯搜索接口
+
+optional arguments:
+  -h, --help            显示帮助信息
+  -q QUERY, --query QUERY
+                        搜索关键词，支持中文
+  -i INPUT, --input INPUT
+                        输入文件路径，每行一个查询词（批量处理）
+  -o OUTPUT, --output OUTPUT
+                        输出文件路径或目录
+  -f {csv,json,text}, --format {csv,json,text}
+                        输出格式 (默认: text)
+  -l LIMIT, --limit LIMIT
+                        每查询返回的最大文章数量 (默认: 10)
+  -d DAYS, --days DAYS  搜索最近多少天内的文章 (默认: 30)
+  --api-key API_KEY     API密钥，如果不提供则从环境变量 IWENCAI_API_KEY 获取
+  --debug               启用调试模式
+```
+
+## 配置说明
+
+### 环境变量
+
+- `IWENCAI_API_KEY`: API密钥（必需）
+- `NEWS_SEARCH_DEFAULT_LIMIT`: 默认返回结果数量
+- `NEWS_SEARCH_DEFAULT_DAYS`: 默认搜索天数
+- `NEWS_SEARCH_LOG_LEVEL`: 日志级别（DEBUG, INFO, WARNING, ERROR, CRITICAL）
+
+### 配置文件
+
+技能支持JSON格式的配置文件，可以创建 `config.json` 文件：
+
+```json
+{
+  "api": {
+    "base_url": "https://openapi.iwencai.com",
+    "endpoint": "/v1/comprehensive/search",
+    "timeout": 30,
+    "max_retries": 3
+  },
+  "search": {
+    "default_limit": 10,
+    "default_days": 30
+  }
+}
+```
+
+## 代码示例
+
+### Python API调用
+
+```python
+from news_search import NewsSearchAPI, NewsProcessor
+
+# 初始化API客户端
+api = NewsSearchAPI()
+
+# 搜索新闻
+articles = api.search("人工智能")
+
+# 处理结果
+processor = NewsProcessor()
+filtered_articles = processor.filter_by_date(articles, days=7)
+sorted_articles = processor.sort_by_date(filtered_articles)
+
+# 保存结果
+processor.save_to_csv(sorted_articles, "results.csv")
+```
+
+### 查询拆解示例
+
+```python
+from news_search import QueryProcessor
+
+# 复杂查询拆解
+query = "人工智能和芯片行业最新动态"
+sub_queries = QueryProcessor.split_complex_query(query)
+# 返回: ["人工智能最新动态", "芯片行业最新动态"]
+```
+
+## 错误处理
+
+技能包含完善的错误处理机制：
+
+1. **网络异常**: 自动重试机制
+2. **API认证失败**: 清晰的错误提示
+3. **请求频率限制**: 指数退避重试
+4. **数据解析错误**: 优雅降级处理
+
+## 输出格式
+
+### CSV格式
+```
+title,summary,url,publish_date,source
+文章标题,文章摘要,文章网址,发布时间,同花顺问财
+```
+
+### JSON格式
+```json
+[
+  {
+    "title": "文章标题",
+    "summary": "文章摘要",
+    "url": "文章网址",
+    "publish_date": "发布时间",
+    "source": "同花顺问财"
+  }
+]
+```
+
+### 文本格式
+```
+============================================================
+查询: 人工智能
+找到 8 篇文章 (最近 30 天)
+============================================================
+
+1. 人工智能助力金融行业数字化转型
+   摘要: 近日，多家金融机构宣布采用人工智能技术优化风��系统...
+   发布时间: 2024-01-15 10:30:00
+   链接: https://example.com/article/123
+```
+
+## 使用场景
+
+### 财经新闻搜索
+```bash
+python news_search.py -q "央行货币政策"
+```
+
+### 行业趋势分析
+```bash
+python news_search.py -q "人工智能行业发展趋势" -d 90 -l 20
+```
+
+### 企业信息查询
+```bash
+python news_search.py -q "腾讯公司最新动态" -o tencent_news.csv -f csv
+```
+
+### 批量数据收集
+```bash
+# 收集多个行业的新闻
+echo "人工智能" > industries.txt
+echo "新能源汽车" >> industries.txt
+echo "生物医药" >> industries.txt
+python news_search.py -i industries.txt -o industry_news/ -f json
+```
+
+## 注意事项
+
+1. **API密钥安全**: API密钥应从环境变量获取，不要硬编码在代码中
+2. **请求频率限制**: 注意API提供商的请求频率限制
+3. **商业用途**: 不得将数据用于商业用途或违反相关法律法规
+
+## 故障排除
+
+### 常见问题
+
+1. **API认证失败**
+   ```
+   错误: API认证失败，请检查API密钥
+   解决方案: 检查 IWENCAI_API_KEY 环境变量是否正确设置
+   ```
+
+2. **网络连接问题**
+   ```
+   错误: 连接错误
+   解决方案: 检查网络连接，或使用 --debug 参数查看详细错误
+   ```
+
+3. **无结果返回**
+   ```
+   未找到相关文章
+   解决方案: 尝试调整查询关键词，或增加搜索天数 (-d 参数)
+   ```
+
+### 调试模式
+
+使用 `--debug` 参数启用详细日志：
+
+```bash
+python news_search.py -q "测试" --debug
+```
+
+## 更新日志
+
+### v1.0.0
+- 实现基础财经资讯搜索功能
+- 支持查询拆解和合并
+- 实现完整错误处理机制
+- 提供详细的使用文档
+
+## 许可证
+
+MIT License
+
+## 技术支持
+
+如有问题或建议，请参考代码注释或联系开发者。

Skills/news-search/SKILL.md

@@ -0,0 +1,316 @@
+---
+name: news-search
+description: 财经领域为主的资讯搜索引擎，囊获了各类型媒体：官媒、主流财经媒体、垂直行业网站、知名上市公司/非上市公司官网等，可以帮助你了解最新财经事件、政策动态、行业革新、企业业务进展等等。
+version: 1.0.0
+---
+
+# 新闻搜索技能
+
+## 版本
+当前技能版本：1.0.0（与X-Claw-Skill-Version头一致）
+
+## 技能概述
+
+本技能是一个财经领域为主的资讯搜索引擎，通过调用同花顺问财的财经资讯搜索接口，帮助用户获取最新的财经新闻、政策动态、行业革新和企业业务进展等信息。本技能严格遵守问财OpenAPI网关规范。
+
+## 首次使用 - 获取 API Key
+
+所有技能都需要 IWENCAI_API_KEY 环境变量才能使用。 如果用户尚未配置，按以下步骤引导：
+
+步骤 1：获取 API Key
+在浏览器内打同花顺i问财SkillHub页面：https://www.iwencai.com/skillhub
+
+步骤 2：登录
+
+步骤 3：点击具体的Skill，打开弹窗查看详情，在安装方式-Agent用户-找到您的IWENCAI_API_KEY这一段，复制
+
+步骤 4：配置环境变量
+获取到 API Key 后，直接复制指引文字发送给AI助手，或手动设置环境变量：
+
+**Unix/Linux/macOS (bash/zsh):**
+```bash
+export IWENCAI_API_KEY="your_api_key_here"
+```
+
+**Windows (PowerShell):**
+```powershell
+$env:IWENCAI_API_KEY="your_api_key_here"
+```
+
+**Windows (CMD):**
+```cmd
+set IWENCAI_API_KEY=your_api_key_here
+```
+
+## 技能功能
+
+### 1. 财经资讯搜索
+- 搜索各类财经新闻和资讯
+- 覆盖官媒、主流财经媒体、垂直行业网站、知名上市公司/非上市公司官网等
+- 支持中文关键词搜索
+
+### 2. 查询处理能力
+- 自动拆解复杂查询为多个简单查询
+- 示例：用户问"最近人工智能和芯片行业有什么新闻？"可以拆分为"人工智能最新动态"和"芯片行业新闻"两个查询
+- 根据查询复杂度决定调用接口的次数
+
+### 3. 数据评估与扩展
+- 自动评估搜索结果是否能回答用户问题
+- 如有必要，可调用其他技能或工具扩展数据
+- 对搜索结果进行质量评估
+
+### 4. 数据处理与返回
+- 对搜索结果进行排序、过滤和摘要处理
+- **⚠️ 重要警告：根据问财OpenAPI网关规范条件六，API原始响应必须透明传递**
+- **必须遵守**：不得对API响应进行二次解析、清洗、重组或再加工
+- **透明传递要求**：
+  - 直接返回API原始响应JSON，不做任何包装
+  - 错误响应也必须原样传递，不得替换为自定义错误信息
+  - 网络层错误（超时、连接失败等）可提供技术性错误信息
+- 将透明传递的响应数据返回给大模型进行处理
+- 大模型负责生成用户友好的回答格式
+
+## 接口信息
+
+### 基础信息
+- **Base URL**: `https://openapi.iwencai.com`
+- **接口路径**: `/v1/comprehensive/search`
+- **请求方式**: POST
+- **认证方式**: API Key (Bearer Token)
+
+### 问财OpenAPI网关规范要求
+
+所有发往问财OpenAPI网关的请求必须遵守以下规范：
+
+#### 1. HTTP请求头要求
+所有请求必须在Header中包含以下字段：
+
+| Header | 取值说明 |
+|--------|----------|
+| `X-Claw-Call-Type` | `normal`：正常请求；`retry`：失败后的重试。按实际调用场景二选一。 |
+| `X-Claw-Skill-Id` | 技能标识，填写 `news-search`。 |
+| `X-Claw-Skill-Version` | 当前技能版本号，填写 `1.0.0`。 |
+| `X-Claw-Plugin-Id` | 插件ID，当前阶段统一填写 `none`。 |
+| `X-Claw-Plugin-Version` | 插件版本，当前阶段统一填写 `none`。 |
+| `X-Claw-Trace-Id` | **每次请求必须新生成**的**全局唯一**追踪ID；**长度为64个字符**（推荐64位十六进制字符串）。 |
+
+#### 2. 认证要求
+使用OAuth2.0/JWT风格认证：
+```
+Authorization: Bearer {IWENCAI_API_KEY}
+```
+其中 `IWENCAI_API_KEY` 必须从环境变量读取，禁止硬编码在代码中。
+
+#### 3. 请求参数
+```json
+{
+  "channels": ["news"],
+  "app_id": "AIME_SKILL",
+  "query": "搜索关键词"
+}
+```
+
+### curl示例（脱敏）
+```bash
+# 生成64位十六进制Trace ID
+TRACE_ID=$(python3 -c "import secrets; print(secrets.token_hex(32))")
+
+# 调用新闻搜索接口
+curl -X POST "https://openapi.iwencai.com/v1/comprehensive/search" \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $IWENCAI_API_KEY" \
+  -H "X-Claw-Call-Type: normal" \
+  -H "X-Claw-Skill-Id: news-search" \
+  -H "X-Claw-Skill-Version: 1.0.0" \
+  -H "X-Claw-Plugin-Id: none" \
+  -H "X-Claw-Plugin-Version: none" \
+  -H "X-Claw-Trace-Id: $TRACE_ID" \
+  -d '{
+    "channels": ["news"],
+    "app_id": "AIME_SKILL",
+    "query": "人工智能"
+  }'
+```
+
+**Windows PowerShell示例：**
+```powershell
+# 生成64位十六进制Trace ID
+$TRACE_ID = python -c "import secrets; print(secrets.token_hex(32))"
+
+# 调用新闻搜索接口
+$headers = @{
+    "Content-Type" = "application/json"
+    "Authorization" = "Bearer $env:IWENCAI_API_KEY"
+    "X-Claw-Call-Type" = "normal"
+    "X-Claw-Skill-Id" = "news-search"
+    "X-Claw-Skill-Version" = "1.0.0"
+    "X-Claw-Plugin-Id" = "none"
+    "X-Claw-Plugin-Version" = "none"
+    "X-Claw-Trace-Id" = $TRACE_ID
+}
+
+$body = @{
+    channels = @("news")
+    app_id = "AIME_SKILL"
+    query = "人工智能"
+} | ConvertTo-Json
+
+Invoke-RestMethod -Uri "https://openapi.iwencai.com/v1/comprehensive/search" -Method Post -Headers $headers -Body $body
+```
+
+## 问财OpenAPI网关核心规范（必须遵守）
+
+### 条件六：返回结果透明传递（Non-Negotiable）
+
+**核心原则：技能生成的代码必须透明传递API响应，不得对返回内容做任何修改、过滤、重组或再加工后再交付给调用方。**
+
+#### 1. 禁止行为
+- 不得对网关返回的 `data`、`result`、`response` 等字段进行二次解析、清洗、重组
+- 不得自行添加、删除、修改返回结果的任何键值或结构
+- 不得在技能生成的代码中将API原始响应包装成另一套 `result` / `output` / `data` 等结构再返回
+- 不得在返回前对响应内容做任何「业务逻辑层」的处理（如字段映射、类型转换、格式化等），这些应由调用方决定如何处理
+
+#### 2. 要求行为
+- **直接透传**：对网关返回的完整HTTP响应体（Body），应在获取后**原封不动**地传递给调用方（或返回给LLM）
+- **透明返回**：若使用Python等语言实现，返回值应为对API响应的直接赋值或简单的 `return response`，不做任何中间transformation
+- **错误传递**：API返回的错误状态码与错误Body也应完整传递，不得替换为自定义错误信息（除非是网络层超时、连接失败等技术性错误）
+
+#### 3. 正确实现示例
+```python
+# ✅ 正确：直接返回API响应
+def search_news(query: str):
+    response = requests.post(url, headers=headers, json=payload)
+    # 直接返回API响应，不做任何处理
+    return response.json()  # 或者 response.text / response.content
+```
+
+#### 4. 错误实现示例
+```python
+# ❌ 错误：对API响应做了二次组装
+def search_news(query: str):
+    resp = requests.post(url, headers=headers, json=payload)
+    data = resp.json()
+    result = {"code": 0, "data": data["result"], "msg": "success"}  # 禁止：自行包装
+    return result
+```
+
+## 使用场景
+
+### 何时调用本技能
+1. **财经新闻搜索**: 当用户需要了解特定行业、公司或主题的最新财经新闻时
+2. **政策动态查询**: 当用户需要了解最新的财经政策、法规变化时
+3. **行业趋势分析**: 当用户需要了解某个行业的最新发展动态和趋势时
+4. **企业信息查询**: 当用户需要了解特定上市公司或非上市公司的业务进展时
+5. **市场动态跟踪**: 当用户需要了解股票市场、债券市场等金融市场的最新动态时
+
+### 调用示例
+1. 用户问："最近人工智能行业有什么新政策？"
+2. 用户问："特斯拉最近的业务进展如何？"
+3. 用户问："芯片行业的最新动态有哪些？"
+4. 用户问："央行最近发布了什么货币政策？"
+
+## 技能内部逻辑
+
+### 查询处理流程
+1. **接收用户查询**: 获取用户的搜索需求
+2. **查询拆解**: 分析查询复杂度，决定是否需要拆分为多个子查询
+3. **API调用**: 生成并执行API调用代码
+4. **数据评估**: 检查返回的数据是否足够回答用户问题
+5. **数据处理**: 对搜索结果进行排序、过滤和摘要
+6. **结果返回**: 将处理后的结果返回给大模型
+
+### 代码生成要求
+- 生成完整的API调用代码，包括认证、请求构造、错误处理
+- 处理网络异常和接口错误
+- 实现重试机制
+- 支持并发处理（可选）
+
+## 技术实现
+
+### Python代码要求
+- 使用Python标准库和常用库
+- 代码结构清晰，模块化设计
+- 包含完整的错误处理
+- 支持配置文件和环境变量
+- 实现日志记录功能
+- 尽量少依赖第三方库
+- 确保代码的可读性和可维护性
+
+### CLI接口要求
+- 提供友好的命令行接口支持
+- 支持以下命令行参数：
+  - `--query` 或 `-q`: 搜索关键词
+  - `--output` 或 `-o`: 输出文件路径
+  - `--input` 或 `-i`: 输入文件路径（批量处理）
+  - `--format` 或 `-f`: 输出格式（csv, json, text）
+  - `--limit` 或 `-l`: 结果数量限制
+  - `--help` 或 `-h`: 显示帮助信息
+- 提供详细的帮助文档和示例用法
+- 支持管道操作和输入输出重定向
+- 支持文件到文件处理，即CLI允许 `input-paths` 和 `output-paths`
+- 数据表格保存为CSV格式
+- 图片URL下载为文件
+- 支持批量处理和分页查询
+
+### 大数据处理能力
+- 探索api接口的输出，考虑数据量较大的情况
+- 支持文件到文件处理
+- 数据表格保存为CSV格式
+- 图片URL下载为文件
+- 支持批量处理和分页查询
+
+### 错误处理
+- 网络异常处理
+- API���证失败处理
+- 请求频率限制处理
+- 数据解析错误处理
+
+### 性能优化
+- 支持大数据量处理
+- 实现缓存机制（可选）
+- 支持并发查询（可选）
+- 优化响应时间
+
+## 注意事项
+
+### API使用规范
+1. API密钥需要从环境变量安全获取：`IWENCAI_API_KEY`
+2. 注意请求频率限制，避免被限制访问
+3. 请求参数中的`channels`和`app_id`为固定值，不要修改
+4. `query`参数支持中文关键词搜索
+
+### 数据使用规范
+1. 确保数据处理的准确性和完整性
+2. 遵循数据隐私和安全规范
+3. 不得将数据用于商业用途或违反相关法律法规
+
+### 技能调用规范
+1. 技能描述使用中文
+2. 提供清晰的调用说明
+3. 支持多种查询场景
+4. 确保技能稳定性和可靠性
+
+## 技能验证
+
+### 验收标准
+1. 技能能够正确安装和运行
+2. 能够成功调用财经资讯搜索接口
+3. 能够处理各种查询场景
+4. 支持大数据量的处理和导出
+5. 代码质量高，符合Python最佳实践
+6. 技能描述使用中文
+
+### 测试用例
+1. 简单查询测试：搜索"人工智能"
+2. 复杂查询测试：搜索"人工智能和芯片行业最新动态"
+3. 错误处理测试：无效API密钥测试
+4. 性能测试：大数据量查询测试
+5. 格式测试：不同输出格式测试
+
+## 更新日志
+
+### v1.0.0 (初始版本)
+- 实现基础财经资讯搜索功能
+- 支持查询拆解和合并
+- 实现完整错误处理机制
+- 提供详细的使用文档

Skills/news-search/references/api.md

@@ -0,0 +1,111 @@
+# 财经资讯搜索接口文档
+
+## 接口概述
+- **接口名称**: 财经资讯搜索接口
+- **接口说明**: 财经领域为主的资讯搜索引擎，囊获了各类型媒体：官媒、主流财经媒体、垂直行业网站、知名上市公司/非上市公司官网等，可以帮助你了解最新财经事件、政策动态、行业革新、企业业务进展等
+
+## 基础信息
+- **Base URL**: `https://openapi.iwencai.com`
+- **接口路径**: `/v1/comprehensive/search`
+- **请求方式**: POST
+- **认证方式**: API Key (Bearer Token)
+
+## 认证要求
+在请求头中需要携带API Key进行认证：
+```
+Authorization: Bearer {IWENCAI_API_KEY}
+```
+其中 `IWENCAI_API_KEY` 是用户申请的有效API密钥，需要设置为环境变量。
+
+## 请求头
+```
+Content-Type: application/json
+Authorization: Bearer {IWENCAI_API_KEY}
+```
+
+## 请求参数
+
+### 固定参数
+| 参数名 | 类型 | 说明 | 值 |
+|--------|------|------|-----|
+| channels | LIST | 搜索渠道类型 | `["news"]` |
+| app_id | STRING | 应用ID | `AIME_SKILL` |
+
+### 可变参数
+| 参数名 | 类型 | 说明 | 必填 |
+|--------|------|------|------|
+| query | STRING | 用户问句，即搜索关键词 | 是 |
+
+### 请求示例
+```json
+{
+  "channels": ["news"],
+  "app_id": "AIME_SKILL",
+  "query": "人工智能行业最新动态"
+}
+```
+
+## 响应参数
+
+### 响应结构
+```json
+{
+  "data": [
+    {
+      "title": "文章标题",
+      "summary": "文章摘要",
+      "url": "文章网址",
+      "publish_date": "文章发布时间"
+    }
+  ]
+}
+```
+
+### 字段说明
+| 字段名 | 类型 | 说明 | 格式 |
+|--------|------|------|------|
+| data | LIST | 返回的文章信息列表 | - |
+| title | STRING | 文章标题 | - |
+| summary | STRING | 文章摘要 | - |
+| url | STRING | 文章网址 | URL格式 |
+| publish_date | STRING | 文章发布时间 | `YYYY-MM-DD HH:MM:SS` |
+
+## 响应示例
+```json
+{
+  "data": [
+    {
+      "title": "人工智能助力金融行业数字化转型",
+      "summary": "近日，多家金融机构宣布采用人工智能技术优化风控系统...",
+      "url": "https://example.com/article/123",
+      "publish_date": "2024-01-15 10:30:00"
+    },
+    {
+      "title": "AI芯片市场迎来爆发式增长",
+      "summary": "随着人工智能应用的普及，AI芯片市场需求持续攀升...",
+      "url": "https://example.com/article/124",
+      "publish_date": "2024-01-14 14:20:00"
+    }
+  ]
+}
+```
+
+## 错误码
+| 状态码 | 说明 | 处理建议 |
+|--------|------|----------|
+| 200 | 请求成功 | - |
+| 400 | 请求参数错误 | 检查请求参数格式和必填项 |
+| 401 | 认证失败 | 检查API Key是否正确且有效 |
+| 403 | 权限不足 | 检查API Key是否有访问此接口的权限 |
+| 500 | 服务器内部错误 | 稍后重试或联系技术支持 |
+
+## 使用限制
+- 请求频率限制：请参考API提供商的具体限制
+- 数据返回限制：每次请求返回的文章数量可能有上限
+- 数据时效性：返回的文章按发布时间倒序排列
+
+## 注意事项
+1. API Key需要妥善保管，不要泄露
+2. 请求参数中的`channels`和`app_id`为固定值，不要修改
+3. `query`参数支持中文关键词搜索
+4. 接口响应时间可能因网络状况和查询复杂度而异

Skills/news-search/scripts/__main__.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+新闻搜索技能命令行入口点
+"""
+
+import sys
+import os
+
+# 添加当前目录到Python路径
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from news_search import main
+
+if __name__ == "__main__":
+    main()

Skills/news-search/scripts/config.example.json

@@ -0,0 +1,24 @@
+{
+  "api": {
+    "base_url": "https://openapi.iwencai.com",
+    "endpoint": "/v1/comprehensive/search",
+    "timeout": 30,
+    "max_retries": 3,
+    "retry_delay": 1.0
+  },
+  "search": {
+    "default_limit": 10,
+    "default_days": 30,
+    "min_articles_for_sufficient": 3
+  },
+  "output": {
+    "default_format": "text",
+    "csv_encoding": "utf-8-sig",
+    "json_indent": 2
+  },
+  "logging": {
+    "level": "INFO",
+    "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+  },
+  "注意": "API密钥应从环境变量 IWENCAI_API_KEY 获取，不要在此配置文件中硬编码"
+}

Skills/news-search/scripts/config.py

@@ -0,0 +1,271 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+新闻搜索技能配置文件
+"""
+
+import os
+import json
+from pathlib import Path
+from typing import Dict, Any, Optional
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class Config:
+    """配置管理类"""
+    
+    DEFAULT_CONFIG = {
+        "api": {
+            "base_url": "https://openapi.iwencai.com",
+            "endpoint": "/v1/comprehensive/search",
+            "timeout": 30,
+            "max_retries": 3,
+            "retry_delay": 1.0,
+        },
+        "search": {
+            "default_limit": 10,
+            "default_days": 30,
+            "min_articles_for_sufficient": 3,
+        },
+        "output": {
+            "default_format": "text",
+            "csv_encoding": "utf-8-sig",
+            "json_indent": 2,
+        },
+        "logging": {
+            "level": "INFO",
+            "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        }
+    }
+    
+    def __init__(self, config_file: Optional[str] = None):
+        """
+        初始化配置
+        
+        Args:
+            config_file: 配置文件路径，如果为None则使用默认配置
+        """
+        self.config_file = config_file
+        self.config = self.DEFAULT_CONFIG.copy()
+        
+        if config_file and Path(config_file).exists():
+            self.load_config(config_file)
+        else:
+            # 尝试从环境变量加载配置
+            self.load_from_env()
+        
+        logger.debug("配置初始化完成")
+    
+    def load_config(self, config_file: str) -> None:
+        """
+        从配置文件加载配置
+        
+        Args:
+            config_file: 配置文件路径
+        """
+        try:
+            with open(config_file, 'r', encoding='utf-8') as f:
+                user_config = json.load(f)
+            
+            # 深度合并配置
+            self._merge_config(self.config, user_config)
+            logger.info(f"已从配置文件加载配置: {config_file}")
+            
+        except json.JSONDecodeError as e:
+            logger.error(f"配置文件格式错误: {config_file} - {str(e)}")
+        except Exception as e:
+            logger.error(f"加载配置文件失败: {config_file} - {str(e)}")
+    
+    def load_from_env(self) -> None:
+        """从环境变量加载配置"""
+        env_config = {}
+        
+        # API配置
+        api_key = os.getenv("IWENCAI_API_KEY")
+        if api_key:
+            env_config["api_key"] = api_key
+        
+        # 搜索配置
+        default_limit = os.getenv("NEWS_SEARCH_DEFAULT_LIMIT")
+        if default_limit:
+            try:
+                env_config.setdefault("search", {})["default_limit"] = int(default_limit)
+            except ValueError:
+                logger.warning(f"无效的环境变量值: NEWS_SEARCH_DEFAULT_LIMIT={default_limit}")
+        
+        default_days = os.getenv("NEWS_SEARCH_DEFAULT_DAYS")
+        if default_days:
+            try:
+                env_config.setdefault("search", {})["default_days"] = int(default_days)
+            except ValueError:
+                logger.warning(f"无效的环境变量值: NEWS_SEARCH_DEFAULT_DAYS={default_days}")
+        
+        # 日志配置
+        log_level = os.getenv("NEWS_SEARCH_LOG_LEVEL")
+        if log_level and log_level in ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]:
+            env_config.setdefault("logging", {})["level"] = log_level
+        
+        if env_config:
+            self._merge_config(self.config, env_config)
+            logger.debug("已从环境变量加载配置")
+    
+    def _merge_config(self, base: Dict[str, Any], update: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        深度合并两个配置字典
+        
+        Args:
+            base: 基础配置
+            update: 更新配置
+            
+        Returns:
+            合并后的配置
+        """
+        for key, value in update.items():
+            if key in base and isinstance(base[key], dict) and isinstance(value, dict):
+                base[key] = self._merge_config(base[key], value)
+            else:
+                base[key] = value
+        return base
+    
+    def save_config(self, config_file: Optional[str] = None) -> None:
+        """
+        保存配置到文件
+        
+        Args:
+            config_file: 配置文件路径，如果为None则使用初始化时的路径
+        """
+        save_file = config_file or self.config_file
+        if not save_file:
+            logger.error("未指定配置文件路径")
+            return
+        
+        try:
+            # 确保目录存在
+            Path(save_file).parent.mkdir(parents=True, exist_ok=True)
+            
+            with open(save_file, 'w', encoding='utf-8') as f:
+                json.dump(self.config, f, ensure_ascii=False, indent=2)
+            
+            logger.info(f"配置已保存到: {save_file}")
+            
+        except Exception as e:
+            logger.error(f"保存配置失败: {save_file} - {str(e)}")
+    
+    def get(self, key: str, default: Any = None) -> Any:
+        """
+        获取配置值
+        
+        Args:
+            key: 配置键，支持点号分隔，如 "api.base_url"
+            default: 默认值
+            
+        Returns:
+            配置值
+        """
+        keys = key.split('.')
+        value = self.config
+        
+        try:
+            for k in keys:
+                value = value[k]
+            return value
+        except (KeyError, TypeError):
+            return default
+    
+    def set(self, key: str, value: Any) -> None:
+        """
+        设置配置值
+        
+        Args:
+            key: 配置键，支持点号分隔，如 "api.base_url"
+            value: 配置值
+        """
+        keys = key.split('.')
+        config = self.config
+        
+        # 遍历到倒数第二个键
+        for k in keys[:-1]:
+            if k not in config or not isinstance(config[k], dict):
+                config[k] = {}
+            config = config[k]
+        
+        # 设置最后一个键的值
+        config[keys[-1]] = value
+        logger.debug(f"配置已更新: {key} = {value}")
+    
+    def get_api_key(self) -> Optional[str]:
+        """获取API密钥"""
+        return os.getenv("IWENCAI_API_KEY") or self.get("api_key")
+    
+    def get_api_config(self) -> Dict[str, Any]:
+        """获取API配置"""
+        return self.get("api", {})
+    
+    def get_search_config(self) -> Dict[str, Any]:
+        """获取搜索配置"""
+        return self.get("search", {})
+    
+    def get_output_config(self) -> Dict[str, Any]:
+        """获取输出配置"""
+        return self.get("output", {})
+    
+    def get_logging_config(self) -> Dict[str, Any]:
+        """获取日志配置"""
+        return self.get("logging", {})
+    
+    def setup_logging(self) -> None:
+        """设置日志配置"""
+        log_config = self.get_logging_config()
+        level = getattr(logging, log_config.get("level", "INFO"))
+        format_str = log_config.get("format", "%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+        
+        logging.basicConfig(
+            level=level,
+            format=format_str
+        )
+        
+        logger.debug(f"日志配置已设置: level={level}")
+
+
+# 全局配置实例
+_config_instance: Optional[Config] = None
+
+
+def get_config(config_file: Optional[str] = None) -> Config:
+    """
+    获取配置实例（单例模式）
+    
+    Args:
+        config_file: 配置文件路径
+        
+    Returns:
+        配置实例
+    """
+    global _config_instance
+    
+    if _config_instance is None:
+        _config_instance = Config(config_file)
+    
+    return _config_instance
+
+
+def create_default_config(config_file: str) -> None:
+    """
+    创建默认配置文件
+    
+    Args:
+        config_file: 配置文件路径
+    """
+    config = Config()
+    config.save_config(config_file)
+    logger.info(f"已创建默认配置文件: {config_file}")
+
+
+if __name__ == "__main__":
+    # 测试配置类
+    config = get_config()
+    print("API配置:", config.get_api_config())
+    print("搜索配置:", config.get_search_config())
+    print("API密钥:", config.get_api_key())

Skills/news-search/scripts/example_usage.py

@@ -0,0 +1,269 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+新闻搜索技能使用示例
+"""
+
+import os
+import sys
+from pathlib import Path
+
+# 添加当前目录到Python路径
+sys.path.insert(0, str(Path(__file__).parent))
+
+from news_search import NewsSearchAPI, NewsProcessor, QueryProcessor
+
+
+def example_basic_search():
+    """基本搜索示例"""
+    print("=" * 60)
+    print("示例1: 基本搜索")
+    print("=" * 60)
+    
+    # 注意: 实际使用时需要设置 IWENCAI_API_KEY 环境变量
+    # export IWENCAI_API_KEY="your_api_key_here"
+    
+    api_key = os.getenv("IWENCAI_API_KEY")
+    if not api_key:
+        print("警告: 未设置 IWENCAI_API_KEY 环境变量")
+        print("请先运行: export IWENCAI_API_KEY='your_api_key_here'")
+        print("使用模拟数据进行演示...")
+        
+        # 模拟数据演示
+        processor = NewsProcessor()
+        test_articles = [
+            {
+                "title": "人工智能助力金融行业数字化转型",
+                "summary": "近日，多家金融机构宣布采用人工智能技术优化风控系统...",
+                "url": "https://example.com/article/123",
+                "publish_date": "2026-04-01 10:30:00"
+            },
+            {
+                "title": "AI芯片市场迎来爆发式增长",
+                "summary": "随着人工智能应用的普及，AI芯片市场需求持续攀升...",
+                "url": "https://example.com/article/124",
+                "publish_date": "2026-03-28 14:20:00"
+            }
+        ]
+        
+        print(f"查询: 人工智能")
+        print(f"找到 {len(test_articles)} 篇文章")
+        print()
+        
+        for i, article in enumerate(test_articles, 1):
+            print(f"{i}. {article['title']}")
+            print(f"   摘要: {article['summary']}")
+            print(f"   发布时间: {article['publish_date']}")
+            print(f"   链接: {article['url']}")
+            print()
+        
+        return
+    
+    # 实际API调用
+    try:
+        api = NewsSearchAPI(api_key=api_key)
+        processor = NewsProcessor()
+        
+        # 搜索
+        query = "人工智能"
+        print(f"搜索查询: {query}")
+        articles = api.search(query)
+        
+        # 处理结果
+        articles = processor.filter_by_date(articles, days=30)
+        articles = processor.sort_by_date(articles)
+        articles = processor.limit_results(articles, 5)
+        
+        print(f"找到 {len(articles)} 篇文章 (最近30天)")
+        print()
+        
+        for i, article in enumerate(articles, 1):
+            print(f"{i}. {article.get('title', '无标题')}")
+            print(f"   摘要: {article.get('summary', '无摘要')[:100]}...")
+            print(f"   发布时间: {article.get('publish_date', '未知时间')}")
+            print(f"   链接: {article.get('url', '无链接')}")
+            print()
+            
+    except Exception as e:
+        print(f"搜索失败: {str(e)}")
+
+
+def example_complex_query():
+    """复杂查询示例"""
+    print("\n" + "=" * 60)
+    print("示例2: 复杂查询拆解")
+    print("=" * 60)
+    
+    query_processor = QueryProcessor()
+    
+    test_queries = [
+        "人工智能和芯片行业",
+        "新能源汽车与锂电池技术",
+        "央行货币政策以及财政政策",
+    ]
+    
+    for query in test_queries:
+        sub_queries = query_processor.split_complex_query(query)
+        print(f"原始查询: '{query}'")
+        print(f"拆解结果: {sub_queries}")
+        print()
+
+
+def example_data_processing():
+    """数据处理示例"""
+    print("\n" + "=" * 60)
+    print("示例3: 数据处理")
+    print("=" * 60)
+    
+    processor = NewsProcessor()
+    
+    # 模拟数据
+    test_articles = [
+        {
+            "title": "文章A",
+            "summary": "摘要A",
+            "url": "http://example.com/a",
+            "publish_date": "2026-04-01 10:30:00"
+        },
+        {
+            "title": "文章B",
+            "summary": "摘要B",
+            "url": "http://example.com/b",
+            "publish_date": "2026-03-15 14:20:00"
+        },
+        {
+            "title": "文章C",
+            "summary": "摘要C",
+            "url": "http://example.com/c",
+            "publish_date": "2026-02-01 09:15:00"
+        }
+    ]
+    
+    print("原始数据:")
+    for article in test_articles:
+        print(f"  - {article['title']} ({article['publish_date']})")
+    
+    # 时间过滤
+    filtered = processor.filter_by_date(test_articles, days=60)
+    print(f"\n时间过滤 (最近60天): {len(filtered)} 篇文章")
+    
+    # 排序
+    sorted_articles = processor.sort_by_date(filtered, reverse=True)
+    print("\n按时间排序 (从新到旧):")
+    for article in sorted_articles:
+        print(f"  - {article['title']} ({article['publish_date']})")
+    
+    # 提取关键信息
+    print("\n关键信息提取示例:")
+    key_info = processor.extract_key_info(test_articles[0])
+    for key, value in key_info.items():
+        print(f"  {key}: {value}")
+
+
+def example_file_export():
+    """文件导出示例"""
+    print("\n" + "=" * 60)
+    print("示例4: 文件导出")
+    print("=" * 60)
+    
+    processor = NewsProcessor()
+    
+    # 模拟数据
+    test_articles = [
+        {
+            "title": "人工智能行业报告",
+            "summary": "2026年人工智能行业发展前景分析",
+            "url": "http://example.com/ai-report",
+            "publish_date": "2026-04-01 10:30:00"
+        },
+        {
+            "title": "芯片技术突破",
+            "summary": "国产芯片实现技术突破，性能提升显著",
+            "url": "http://example.com/chip-breakthrough",
+            "publish_date": "2026-03-28 14:20:00"
+        }
+    ]
+    
+    import tempfile
+    import json
+    
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmpdir = Path(tmpdir)
+        
+        # CSV导出
+        csv_path = tmpdir / "news.csv"
+        processor.save_to_csv(test_articles, str(csv_path))
+        print(f"CSV文件已保存: {csv_path}")
+        
+        # JSON导出
+        json_path = tmpdir / "news.json"
+        processor.save_to_json(test_articles, str(json_path))
+        print(f"JSON文件已保存: {json_path}")
+        
+        # 验证JSON内容
+        with open(json_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+            print(f"\nJSON文件内容验证:")
+            print(f"  文章数量: {len(data)}")
+            print(f"  第一篇文章标题: {data[0]['title']}")
+
+
+def example_cli_usage():
+    """CLI使用示例"""
+    print("\n" + "=" * 60)
+    print("示例5: CLI命令行使用")
+    print("=" * 60)
+    
+    print("""
+基本用法:
+  python news_search.py -q "人工智能"
+  
+搜索最近7天的新闻:
+  python news_search.py -q "芯片行业" -d 7
+  
+限制返回结果数量:
+  python news_search.py -q "新能源汽车" -l 5
+  
+导出为CSV格式:
+  python news_search.py -q "人工智能" -o results.csv -f csv
+  
+导出为JSON格式:
+  python news_search.py -q "人工智能" -o results.json -f json
+  
+批量处理:
+  python news_search.py -i queries.txt -o output/ -f csv
+  
+管道操作:
+  echo "人工智能" | python news_search.py
+  
+启用调试模式:
+  python news_search.py -q "测试" --debug
+    """)
+
+
+def main():
+    """主函数"""
+    print("新闻搜索技能使用示例")
+    print("=" * 60)
+    print()
+    
+    examples = [
+        example_basic_search,
+        example_complex_query,
+        example_data_processing,
+        example_file_export,
+        example_cli_usage,
+    ]
+    
+    for example_func in examples:
+        example_func()
+        input("\n按Enter键继续...")
+        print()
+    
+    print("=" * 60)
+    print("示例演示完成！")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()

Skills/news-search/scripts/news_search.py

@@ -0,0 +1,792 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+新闻搜索技能主文件
+财经领域资讯搜索引擎，调用同花顺问财的财经资讯搜索接口
+
+本技能遵守问财OpenAPI网关规范：
+1. 所有请求必须包含X-Claw-* HTTP头
+2. 使用Bearer Token认证，从IWENCAI_API_KEY环境变量读取
+3. 每次请求生成64字符唯一Trace ID
+4. 支持跨平台使用
+"""
+
+import os
+import sys
+import json
+import logging
+import argparse
+import secrets
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+import csv
+import time
+import requests
+from pathlib import Path
+
+# 配置日志
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+class NewsSearchAPI:
+    """同花顺问财经资讯搜索API封装类"""
+    
+    def __init__(self, api_key: Optional[str] = None):
+        """
+        初始化API客户端
+        
+        Args:
+            api_key: API密钥，如果为None则从环境变量获取
+        """
+        self.base_url = "https://openapi.iwencai.com"
+        self.endpoint = "/v1/comprehensive/search"
+        self.api_key = api_key or os.getenv("IWENCAI_API_KEY")
+        
+        if not self.api_key:
+            raise ValueError("API密钥未设置。请设置环境变量 IWENCAI_API_KEY 或通过参数传入")
+        
+        self.session = requests.Session()
+        
+        # 基础请求头
+        base_headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+            "User-Agent": "NewsSearchSkill/1.0.0"
+        }
+        
+        self.session.headers.update(base_headers)
+        
+        logger.info("NewsSearchAPI客户端初始化完成")
+    
+    def _generate_trace_id(self) -> str:
+        """
+        生成64字符的唯一Trace ID
+        
+        Returns:
+            64字符的十六进制字符串
+        """
+        return secrets.token_hex(32)
+    
+    def _get_headers(self, call_type: str = "normal") -> Dict[str, str]:
+        """
+        获取问财OpenAPI网关要求的HTTP头
+        
+        Args:
+            call_type: 调用类型，normal或retry
+            
+        Returns:
+            包含问财OpenAPI网关要求的HTTP头的字典
+        """
+        headers = self.session.headers.copy()
+        
+        # 添加问财OpenAPI网关要求的HTTP头
+        headers.update({
+            "X-Claw-Call-Type": call_type,
+            "X-Claw-Skill-Id": "news-search",
+            "X-Claw-Skill-Version": "1.0.0",
+            "X-Claw-Plugin-Id": "none",
+            "X-Claw-Plugin-Version": "none",
+            "X-Claw-Trace-Id": self._generate_trace_id()
+        })
+        
+        return headers
+    
+    def search_raw(self, query: str, max_retries: int = 3, call_type: str = "normal") -> Dict[str, Any]:
+        """
+        搜索财经资讯（原始响应，符合问财OpenAPI网关透明传递要求）
+        
+        Args:
+            query: 搜索关键词
+            max_retries: 最大重试次数
+            call_type: 调用类型，normal或retry
+            
+        Returns:
+            API原始响应JSON，不做任何处理
+            
+        Note:
+            根据问财OpenAPI网关规范条件六，此方法必须透明传递所有API响应，
+            包括错误响应，不做任何修改、过滤或重组。
+        """
+        payload = {
+            "channels": ["news"],
+            "app_id": "AIME_SKILL",
+            "query": query
+        }
+        
+        url = f"{self.base_url}{self.endpoint}"
+        
+        for attempt in range(max_retries):
+            try:
+                logger.info(f"搜索查询: {query} (尝试 {attempt + 1}/{max_retries})")
+                
+                # 获取问财OpenAPI网关要求的HTTP头
+                headers = self._get_headers(call_type)
+                
+                response = self.session.post(url, json=payload, headers=headers, timeout=30)
+                
+                # 完全透明传递：尝试返回JSON响应，如果不是JSON则返回文本
+                try:
+                    return response.json()
+                except ValueError:
+                    # API返回的不是JSON格式，返回原始文本
+                    logger.warning(f"API返回非JSON响应，状态码: {response.status_code}")
+                    return {
+                        "error": "invalid_json_response",
+                        "raw_response": response.text,
+                        "status_code": response.status_code,
+                        "headers": dict(response.headers)
+                    }
+                    
+            except requests.exceptions.Timeout:
+                logger.warning(f"请求超时 (尝试 {attempt + 1}/{max_retries})")
+                if attempt < max_retries - 1:
+                    time.sleep(2 ** attempt)  # 指数退避
+                else:
+                    # 网络错误：返回错误信息，但仍保持透明结构
+                    raise requests.exceptions.Timeout(f"请求超时，已达到最大重试次数: {max_retries}")
+            except requests.exceptions.ConnectionError:
+                logger.warning(f"连接错误 (尝试 {attempt + 1}/{max_retries})")
+                if attempt < max_retries - 1:
+                    time.sleep(2 ** attempt)  # 指数退避
+                else:
+                    # 网络错误：抛出异常，由调用方处理
+                    raise requests.exceptions.ConnectionError(f"连接错误，已达到最大重试次数: {max_retries}")
+            except Exception as e:
+                logger.error(f"搜索过程中发生错误: {str(e)}")
+                if attempt < max_retries - 1:
+                    time.sleep(2 ** attempt)  # 指数退避
+                else:
+                    raise
+        
+        # 不应该执行到这里，但如果执行到了，抛出异常
+        raise Exception(f"搜索失败，已达到最大重试次数: {max_retries}")
+    
+    def search(self, query: str, max_retries: int = 3, call_type: str = "normal") -> Dict[str, Any]:
+        """
+        搜索财经资讯（透明传递包装方法）
+        
+        Args:
+            query: 搜索关键词
+            max_retries: 最大重试次数
+            call_type: 调用类型，normal或retry
+            
+        Returns:
+            API原始响应JSON，完全透明传递，不做任何修改
+            
+        Note:
+            根据问财OpenAPI网关规范条件六，此方法完全透明传递API响应，
+            调用方需要自己处理响应数据。这是推荐的使用方式。
+        """
+        return self.search_raw(query, max_retries, call_type)
+    
+    
+    
+    def batch_search(self, queries: List[str], delay: float = 1.0, call_type: str = "normal") -> Dict[str, Dict[str, Any]]:
+        """
+        批量搜索（透明传递版本）
+        
+        Args:
+            queries: 搜索关键词列表
+            delay: 每次请求之间的延迟（秒），避免触发频率限制
+            call_type: 调用类型，normal或retry
+            
+        Returns:
+            字典，键为查询词，值为对应的透明传递的API响应
+            
+        Note:
+            此方法完全透明传递API响应，符合问财规范条件六。
+            调用方需要自己处理响应数据。
+        """
+        results = {}
+        
+        for i, query in enumerate(queries):
+            try:
+                logger.info(f"批量搜索进度: {i+1}/{len(queries)} - {query}")
+                response = self.search(query, call_type=call_type)
+                results[query] = response
+                
+                # 避免触发频率限制
+                if i < len(queries) - 1:
+                    time.sleep(delay)
+                    
+            except Exception as e:
+                logger.error(f"查询 '{query}' 搜索失败: {str(e)}")
+                results[query] = {"error": "search_failed", "message": str(e)}
+        
+        return results
+
+
+class NewsProcessor:
+    """新闻数据处理类"""
+    
+    @staticmethod
+    def filter_by_date(articles: List[Dict[str, Any]], days: int = 7) -> List[Dict[str, Any]]:
+        """
+        按时间过滤文章
+        
+        Args:
+            articles: 文章列表
+            days: 最近多少天内的文章
+            
+        Returns:
+            过滤后的文章列表
+        """
+        if not articles:
+            return []
+        
+        cutoff_date = datetime.now().timestamp() - (days * 24 * 60 * 60)
+        filtered = []
+        
+        for article in articles:
+            publish_date = article.get("publish_date")
+            if not publish_date:
+                continue
+                
+            try:
+                # 尝试解析日期字符串
+                if isinstance(publish_date, str):
+                    # 移除可能的时区信息
+                    publish_date = publish_date.split('+')[0].strip()
+                    dt = datetime.strptime(publish_date, "%Y-%m-%d %H:%M:%S")
+                    article_timestamp = dt.timestamp()
+                    
+                    if article_timestamp >= cutoff_date:
+                        filtered.append(article)
+            except (ValueError, TypeError):
+                # 如果日期解析失败，保留文章
+                filtered.append(article)
+        
+        logger.info(f"时间过滤: 从 {len(articles)} 篇文章中过滤出 {len(filtered)} 篇最近 {days} 天的文章")
+        return filtered
+    
+    @staticmethod
+    def sort_by_date(articles: List[Dict[str, Any]], reverse: bool = True) -> List[Dict[str, Any]]:
+        """
+        按发布时间排序
+        
+        Args:
+            articles: 文章列表
+            reverse: True表示从新到旧，False表示从旧到新
+            
+        Returns:
+            排序后的文章列表
+        """
+        def get_timestamp(article):
+            publish_date = article.get("publish_date")
+            if not publish_date:
+                return 0
+                
+            try:
+                if isinstance(publish_date, str):
+                    publish_date = publish_date.split('+')[0].strip()
+                    dt = datetime.strptime(publish_date, "%Y-%m-%d %H:%M:%S")
+                    return dt.timestamp()
+            except (ValueError, TypeError):
+                pass
+            return 0
+        
+        sorted_articles = sorted(articles, key=get_timestamp, reverse=reverse)
+        return sorted_articles
+    
+    @staticmethod
+    def limit_results(articles: List[Dict[str, Any]], limit: int) -> List[Dict[str, Any]]:
+        """
+        限制结果数量
+        
+        Args:
+            articles: 文章列表
+            limit: 最大返回数量
+            
+        Returns:
+            限制数量后的文章列表
+        """
+        if limit <= 0:
+            return articles
+        return articles[:limit]
+    
+    @staticmethod
+    def extract_key_info(article: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        提取文章关键信息
+        
+        Args:
+            article: 文章字典
+            
+        Returns:
+            包含关键信息的字典
+        """
+        return {
+            "title": article.get("title", ""),
+            "summary": article.get("summary", ""),
+            "url": article.get("url", ""),
+            "publish_date": article.get("publish_date", ""),
+            "source": "同花顺问财"
+        }
+    
+    @staticmethod
+    def save_to_csv(articles: List[Dict[str, Any]], filepath: str) -> None:
+        """
+        保存文章到CSV文件
+        
+        Args:
+            articles: 文章列表
+            filepath: CSV文件路径
+        """
+        if not articles:
+            logger.warning("没有文章数据可保存到CSV")
+            return
+        
+        # 提取关键信息
+        processed_articles = [NewsProcessor.extract_key_info(article) for article in articles]
+        
+        # 确保目录存在
+        Path(filepath).parent.mkdir(parents=True, exist_ok=True)
+        
+        with open(filepath, 'w', newline='', encoding='utf-8-sig') as f:
+            if processed_articles:
+                fieldnames = list(processed_articles[0].keys())
+                writer = csv.DictWriter(f, fieldnames=fieldnames)
+                writer.writeheader()
+                writer.writerows(processed_articles)
+        
+        logger.info(f"已保存 {len(processed_articles)} 篇文章到 {filepath}")
+    
+    @staticmethod
+    def save_to_json(articles: List[Dict[str, Any]], filepath: str) -> None:
+        """
+        保存文章到JSON文件
+        
+        Args:
+            articles: 文章列表
+            filepath: JSON文件路径
+        """
+        if not articles:
+            logger.warning("没有文章数据可保存到JSON")
+            return
+        
+        # 提取关键信息
+        processed_articles = [NewsProcessor.extract_key_info(article) for article in articles]
+        
+        # 确保目录存在
+        Path(filepath).parent.mkdir(parents=True, exist_ok=True)
+        
+        with open(filepath, 'w', encoding='utf-8') as f:
+            json.dump(processed_articles, f, ensure_ascii=False, indent=2)
+        
+        logger.info(f"已保存 {len(processed_articles)} 篇文章到 {filepath}")
+
+
+class QueryProcessor:
+    """查询处理类，负责思维链拆解"""
+    
+    @staticmethod
+    def split_complex_query(query: str) -> List[str]:
+        """
+        拆解复杂查询
+        
+        Args:
+            query: 原始查询
+            
+        Returns:
+            拆解后的查询列表
+        """
+        # 常见的连接词
+        connectors = ["和", "与", "及", "以及", "还有", "并且", "同时"]
+        
+        # 检查是否需要拆解
+        needs_split = False
+        for connector in connectors:
+            if connector in query:
+                needs_split = True
+                break
+        
+        if not needs_split:
+            return [query]
+        
+        # 简单的拆解逻辑
+        sub_queries = []
+        current_query = query
+        
+        for connector in connectors:
+            if connector in current_query:
+                parts = current_query.split(connector)
+                # 处理每个部分
+                for part in parts:
+                    part = part.strip()
+                    if part:
+                        # 进一步检查是否还有连接词
+                        sub_queries.extend(QueryProcessor.split_complex_query(part))
+                break
+        
+        # 如果没有拆解成功，返回原始查询
+        if not sub_queries:
+            sub_queries = [query]
+        
+        # 去重
+        unique_queries = []
+        for q in sub_queries:
+            if q not in unique_queries:
+                unique_queries.append(q)
+        
+        logger.info(f"查询拆解: '{query}' -> {unique_queries}")
+        return unique_queries
+    
+    @staticmethod
+    def evaluate_results(articles: List[Dict[str, Any]], min_articles: int = 3) -> bool:
+        """
+        评估搜索结果是否足够
+        
+        Args:
+            articles: 文章列表
+            min_articles: 最小文章数量要求
+            
+        Returns:
+            是否足够
+        """
+        if len(articles) >= min_articles:
+            logger.info(f"搜索结果评估: 足够 ({len(articles)} 篇文章)")
+            return True
+        else:
+            logger.warning(f"搜索结果评估: 不足 (只有 {len(articles)} 篇文章，需要至少 {min_articles} 篇)")
+            return False
+
+
+def main():
+    """主函数，处理命令行参数"""
+    parser = argparse.ArgumentParser(
+        description="财经新闻搜索工具 - 调用同花顺问财的财经资讯搜索接口（遵守问财OpenAPI网关规范）",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+示例:
+  %(prog)s -q "人工智能"
+  %(prog)s -q "人工智能和芯片行业" -o results.csv -f csv
+  %(prog)s -i queries.txt -o output/ -f json
+  echo "人工智能" | %(prog)s -f text
+
+问财OpenAPI网关规范要求:
+1. 所有请求必须包含X-Claw-* HTTP头（X-Claw-Call-Type, X-Claw-Skill-Id, X-Claw-Skill-Version等）
+2. 使用Bearer Token认证，从IWENCAI_API_KEY环境变量读取API密钥
+3. 每次请求生成64字符全局唯一Trace ID
+4. 返回结果完全透明传递，不对API响应做任何修改、过滤或重组
+
+curl示例（脱敏，请替换占位符）:
+  Unix/Linux/macOS:
+    export IWENCAI_API_KEY="your_api_key_here"
+    curl -X POST https://openapi.iwencai.com/v1/comprehensive/search \
+      -H "Content-Type: application/json" \
+      -H "Authorization: Bearer $IWENCAI_API_KEY" \
+      -H "X-Claw-Call-Type: normal" \
+      -H "X-Claw-Skill-Id: news-search" \
+      -H "X-Claw-Skill-Version: 1.0.0" \
+      -H "X-Claw-Plugin-Id: none" \
+      -H "X-Claw-Plugin-Version: none" \
+      -H "X-Claw-Trace-Id: $(openssl rand -hex 32)" \
+      -d '{"channels":["news"],"app_id":"AIME_SKILL","query":"人工智能"}'
+
+  Windows PowerShell:
+    $env:IWENCAI_API_KEY="your_api_key_here"
+    $traceId = -join ((48..57)+(65..70)+(97..102) | Get-Random -Count 64 | ForEach-Object { [char]$_ })
+    curl.exe -X POST https://openapi.iwencai.com/v1/comprehensive/search `
+      -H "Content-Type: application/json" `
+      -H "Authorization: Bearer $env:IWENCAI_API_KEY" `
+      -H "X-Claw-Call-Type: normal" `
+      -H "X-Claw-Skill-Id: news-search" `
+      -H "X-Claw-Skill-Version: 1.0.0" `
+      -H "X-Claw-Plugin-Id: none" `
+      -H "X-Claw-Plugin-Version: none" `
+      -H "X-Claw-Trace-Id: $traceId" `
+      -d '{\"channels\":[\"news\"],\"app_id\":\"AIME_SKILL\",\"query\":\"人工智能\"}'
+
+环境变量设置（跨平台）:
+  Unix/Linux/macOS (bash/zsh):
+    export IWENCAI_API_KEY="your_api_key_here"
+
+  Windows PowerShell:
+    $env:IWENCAI_API_KEY="your_api_key_here"
+
+  Windows CMD:
+    set IWENCAI_API_KEY=your_api_key_here
+
+获取API密钥:
+  1. 访问同花顺i问财SkillHub: https://www.iwencai.com/skillhub
+  2. 登录账号
+  3. 点击具体技能，在安装方式-Agent用户中查找您的IWENCAI_API_KEY并复制
+  4. 按照上述方式设置环境变量
+        """
+    )
+    
+    # 输入参数
+    input_group = parser.add_mutually_exclusive_group(required=True)
+    input_group.add_argument(
+        "-q", "--query",
+        help="搜索关键词，支持中文"
+    )
+    input_group.add_argument(
+        "-i", "--input",
+        help="输入文件路径，每行一个查询词（批量处理）"
+    )
+    
+    # 输出参数
+    parser.add_argument(
+        "-o", "--output",
+        help="输出文件路径或目录"
+    )
+    parser.add_argument(
+        "-f", "--format",
+        choices=["csv", "json", "text"],
+        default="text",
+        help="输出格式 (默认: text)"
+    )
+    
+    # 搜索参数
+    parser.add_argument(
+        "-l", "--limit",
+        type=int,
+        default=10,
+        help="每查询返回的最大文章数量 (默认: 10)"
+    )
+    parser.add_argument(
+        "-d", "--days",
+        type=int,
+        default=30,
+        help="搜索最近多少天内的文章 (默认: 30)"
+    )
+    parser.add_argument(
+        "--api-key",
+        help="API密钥，如果不提供则从环境变量 IWENCAI_API_KEY 获取"
+    )
+    
+    # 其他参数
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="启用调试模式"
+    )
+    
+    args = parser.parse_args()
+    
+    # 设置日志级别
+    if args.debug:
+        logging.getLogger().setLevel(logging.DEBUG)
+        logger.debug("调试模式已启用")
+    
+    try:
+        # 初始化API客户端
+        api = NewsSearchAPI(api_key=args.api_key)
+        processor = NewsProcessor()
+        query_processor = QueryProcessor()
+        
+        # 处理输入
+        if args.input:
+            # 批量处理模式
+            with open(args.input, 'r', encoding='utf-8') as f:
+                queries = [line.strip() for line in f if line.strip()]
+            
+            if not queries:
+                logger.error("输入文件为空")
+                sys.exit(1)
+            
+            logger.info(f"批量处理 {len(queries)} 个查询")
+            all_results = {}
+            
+            for query in queries:
+                # 拆解复杂查询
+                sub_queries = query_processor.split_complex_query(query)
+                query_results = []
+                
+                for sub_query in sub_queries:
+                    try:
+                        # 获取透明传递的API响应
+                        response = api.search(sub_query)
+                        
+                        # 检查是否为错误响应
+                        if "error" in response:
+                            # 应用层可以选择性展示关键错误信息
+                            error_type = response.get("error", "unknown")
+                            status_code = response.get("status_code", 0)
+                            raw_response = response.get("raw_response", "")
+                            
+                            # 对于常见错误（如401），只显示raw_response
+                            if status_code == 401 and raw_response:
+                                print(f"\n查询 '{query}' - 子查询 '{sub_query}' API错误 (状态码: {status_code}):")
+                                print(raw_response)
+                            else:
+                                # 其他错误显示完整信息
+                                print(f"\n查询 '{query}' - 子查询 '{sub_query}' API错误响应:")
+                                print(json.dumps(response, indent=2, ensure_ascii=False))
+                            continue
+                        
+                        # 从响应中提取文章数据（在应用层处理，不在API层）
+                        articles = response.get("data", [])
+                        query_results.extend(articles)
+                    except Exception as e:
+                        logger.error(f"查询 '{sub_query}' 失败: {str(e)}")
+                
+                all_results[query] = query_results
+            
+            # 处理输出
+            if args.output:
+                output_dir = Path(args.output)
+                if output_dir.suffix:  # 是文件
+                    if args.format == "csv":
+                        # 合并所有结果到一个CSV文件
+                        all_articles = []
+                        for query, articles in all_results.items():
+                            for article in articles:
+                                article["original_query"] = query
+                                all_articles.append(article)
+                        
+                        processor.save_to_csv(all_articles, str(output_dir))
+                    elif args.format == "json":
+                        # 保存为JSON
+                        output_data = {}
+                        for query, articles in all_results.items():
+                            output_data[query] = [
+                                processor.extract_key_info(article) for article in articles
+                            ]
+                        
+                        output_dir.parent.mkdir(parents=True, exist_ok=True)
+                        with open(output_dir, 'w', encoding='utf-8') as f:
+                            json.dump(output_data, f, ensure_ascii=False, indent=2)
+                        logger.info(f"已保存批量结果到 {output_dir}")
+                else:  # 是目录
+                    output_dir.mkdir(parents=True, exist_ok=True)
+                    for query, articles in all_results.items():
+                        # 创建安全的文件名
+                        safe_filename = "".join(c for c in query if c.isalnum() or c in (' ', '-', '_')).rstrip()
+                        safe_filename = safe_filename[:50]  # 限制文件名长度
+                        
+                        if args.format == "csv":
+                            filepath = output_dir / f"{safe_filename}.csv"
+                            processor.save_to_csv(articles, str(filepath))
+                        elif args.format == "json":
+                            filepath = output_dir / f"{safe_filename}.json"
+                            processor.save_to_json(articles, str(filepath))
+            
+            # 文本输出
+            if args.format == "text" or not args.output:
+                for query, articles in all_results.items():
+                    print(f"\n{'='*60}")
+                    print(f"查询: {query}")
+                    print(f"{'='*60}")
+                    
+                    if not articles:
+                        print("未找到相关文章")
+                        continue
+                    
+                    # 处理文章
+                    articles = processor.filter_by_date(articles, args.days)
+                    articles = processor.sort_by_date(articles)
+                    articles = processor.limit_results(articles, args.limit)
+                    
+                    for i, article in enumerate(articles, 1):
+                        print(f"\n{i}. {article.get('title', '无标题')}")
+                        print(f"   摘要: {article.get('summary', '无摘要')}")
+                        print(f"   发布时间: {article.get('publish_date', '未知时间')}")
+                        print(f"   链接: {article.get('url', '无链接')}")
+        
+        else:
+            # 单查询模式
+            query = args.query
+            
+            # 检查是否从管道读取
+            if not sys.stdin.isatty() and not query:
+                query = sys.stdin.read().strip()
+            
+            if not query:
+                logger.error("未提供查询关键词")
+                parser.print_help()
+                sys.exit(1)
+            
+            logger.info(f"处理查询: {query}")
+            
+            # 拆解复杂查询
+            sub_queries = query_processor.split_complex_query(query)
+            all_articles = []
+            
+            for sub_query in sub_queries:
+                try:
+                    # 获取透明传递的API响应
+                    response = api.search(sub_query)
+                    
+                    # 检查是否为错误响应
+                    if "error" in response:
+                        # 应用层可以选择性展示关键错误信息
+                        error_type = response.get("error", "unknown")
+                        status_code = response.get("status_code", 0)
+                        raw_response = response.get("raw_response", "")
+                        
+                        # 对于常见错误（如401），只显示raw_response
+                        if status_code == 401 and raw_response:
+                            print(f"\n{'='*60}")
+                            print(f"API错误 (状态码: {status_code}):")
+                            print(f"{'='*60}")
+                            print(raw_response)
+                            print(f"{'='*60}")
+                        else:
+                            # 其他错误显示完整信息
+                            print(f"\n{'='*60}")
+                            print(f"API错误响应（透明传递）:")
+                            print(f"{'='*60}")
+                            print(json.dumps(response, indent=2, ensure_ascii=False))
+                            print(f"{'='*60}")
+                        continue
+                    
+                    # 从响应中提取文章数据（在应用层处理，不在API层）
+                    articles = response.get("data", [])
+                    all_articles.extend(articles)
+                    logger.info(f"子查询 '{sub_query}' 找到 {len(articles)} 篇文章")
+                except Exception as e:
+                    logger.error(f"子查询 '{sub_query}' 失败: {str(e)}")
+            
+            # 评估结果
+            if not query_processor.evaluate_results(all_articles):
+                logger.warning("搜索结果可能不足以完整回答问题")
+            
+            # 处理文章
+            all_articles = processor.filter_by_date(all_articles, args.days)
+            all_articles = processor.sort_by_date(all_articles)
+            all_articles = processor.limit_results(all_articles, args.limit)
+            
+            # 处理输出
+            if args.output:
+                if args.format == "csv":
+                    processor.save_to_csv(all_articles, args.output)
+                elif args.format == "json":
+                    processor.save_to_json(all_articles, args.output)
+            
+            # 文本输出
+            if args.format == "text" or not args.output:
+                print(f"\n{'='*60}")
+                print(f"查询: {query}")
+                print(f"找到 {len(all_articles)} 篇文章 (最近 {args.days} 天)")
+                print(f"{'='*60}")
+                
+                if not all_articles:
+                    print("未找到相关文章")
+                else:
+                    for i, article in enumerate(all_articles, 1):
+                        print(f"\n{i}. {article.get('title', '无标题')}")
+                        print(f"   摘要: {article.get('summary', '无摘要')}")
+                        print(f"   发布时间: {article.get('publish_date', '未知时间')}")
+                        print(f"   链接: {article.get('url', '无链接')}")
+        
+        logger.info("新闻搜索完成")
+        
+    except ValueError as e:
+        logger.error(f"参数错误: {str(e)}")
+        sys.exit(1)
+    except Exception as e:
+        logger.error(f"程序执行错误: {str(e)}")
+        if args.debug:
+            import traceback
+            traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

Skills/news-search/scripts/requirements.txt

@@ -0,0 +1,2 @@
+# 新闻搜索技能依赖
+requests>=2.25.0

Skills/news-search/scripts/setup.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+新闻搜索技能安装脚本
+"""
+
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="news-search-skill",
+    version="1.0.0",
+    author="News Search Skill",
+    author_email="",
+    description="财经领域资讯搜索引擎，调用同花顺问财的财经资讯搜索接口",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.7",
+    install_requires=[
+        "requests>=2.25.0",
+    ],
+    entry_points={
+        "console_scripts": [
+            "news-search=.trae.skills.新闻搜索.news_search:main",
+        ],
+    },
+)

Skills/news-search/scripts/test_basic.py

@@ -0,0 +1,223 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+新闻搜索技能基本测试
+"""
+
+import os
+import sys
+import json
+import tempfile
+from pathlib import Path
+
+# 添加当前目录到Python路径
+sys.path.insert(0, str(Path(__file__).parent))
+
+from news_search import NewsSearchAPI, NewsProcessor, QueryProcessor
+
+
+def test_query_processor():
+    """测试查询处理器"""
+    print("测试查询处理器...")
+    
+    processor = QueryProcessor()
+    
+    # 测试简单查询
+    simple_query = "人工智能"
+    result = processor.split_complex_query(simple_query)
+    print(f"简单查询 '{simple_query}' -> {result}")
+    assert result == ["人工智能"], f"期望 ['人工智能']，得到 {result}"
+    
+    # 测试复杂查询
+    complex_query = "人工智能和芯片行业最新动态"
+    result = processor.split_complex_query(complex_query)
+    print(f"复杂查询 '{complex_query}' -> {result}")
+    assert len(result) >= 2, f"期望至少2个子查询，得到 {len(result)}"
+    
+    # 测试更多连接词
+    test_cases = [
+        ("A与B", ["A", "B"]),
+        ("A及B", ["A", "B"]),
+        ("A以及B", ["A", "B"]),
+        ("A还有B", ["A", "B"]),
+        ("A并且B", ["A", "B"]),
+        ("A同时B", ["A", "B"]),
+    ]
+    
+    for query, expected_prefix in test_cases:
+        result = processor.split_complex_query(query)
+        print(f"连接词测试 '{query}' -> {result}")
+        assert len(result) >= 2, f"期望至少2个子查询，得到 {len(result)}"
+    
+    print("查询处理器测试通过！\n")
+
+
+def test_news_processor():
+    """测试新闻处理器"""
+    print("测试新闻处理器...")
+    
+    processor = NewsProcessor()
+    
+    # 测试数据 - 使用当前日期附近的日期
+    from datetime import datetime, timedelta
+    now = datetime.now()
+    
+    test_articles = [
+        {
+            "title": "文章1",
+            "summary": "摘要1",
+            "url": "http://example.com/1",
+            "publish_date": (now - timedelta(days=1)).strftime("%Y-%m-%d %H:%M:%S")
+        },
+        {
+            "title": "文章2",
+            "summary": "摘要2",
+            "url": "http://example.com/2",
+            "publish_date": (now - timedelta(days=5)).strftime("%Y-%m-%d %H:%M:%S")
+        },
+        {
+            "title": "文章3",
+            "summary": "摘要3",
+            "url": "http://example.com/3",
+            "publish_date": (now - timedelta(days=40)).strftime("%Y-%m-%d %H:%M:%S")
+        }
+    ]
+    
+    # 测试时间过滤
+    filtered = processor.filter_by_date(test_articles, days=30)
+    print(f"时间过滤: 从 {len(test_articles)} 篇文章中过滤出 {len(filtered)} 篇最近30天的文章")
+    assert len(filtered) >= 2, f"期望至少2篇文章，得到 {len(filtered)}"
+    
+    # 测试排序
+    sorted_articles = processor.sort_by_date(test_articles, reverse=True)
+    print("排序测试: 文章按时间从新到旧排序")
+    
+    # 测试数量限制
+    limited = processor.limit_results(test_articles, 2)
+    print(f"数量限制: 限制为2篇文章，得到 {len(limited)} 篇")
+    assert len(limited) == 2, f"期望2篇文章，得到 {len(limited)}"
+    
+    # 测试关键信息提取
+    key_info = processor.extract_key_info(test_articles[0])
+    print(f"关键信息提取: {key_info}")
+    assert "title" in key_info
+    assert "source" in key_info
+    assert key_info["source"] == "同花顺问财"
+    
+    # 测试文件保存
+    with tempfile.TemporaryDirectory() as tmpdir:
+        # 测试CSV保存
+        csv_path = Path(tmpdir) / "test.csv"
+        processor.save_to_csv(test_articles, str(csv_path))
+        print(f"CSV保存测试: 文件已保存到 {csv_path}")
+        assert csv_path.exists()
+        
+        # 测试JSON保存
+        json_path = Path(tmpdir) / "test.json"
+        processor.save_to_json(test_articles, str(json_path))
+        print(f"JSON保存测试: 文件已保存到 {json_path}")
+        assert json_path.exists()
+        
+        # 验证JSON内容
+        with open(json_path, 'r', encoding='utf-8') as f:
+            loaded_data = json.load(f)
+            assert len(loaded_data) == len(test_articles)
+            assert loaded_data[0]["source"] == "同花顺问财"
+    
+    print("新闻处理器测试通过！\n")
+
+
+def test_api_client_structure():
+    """测试API客户端结构（不实际调用API）"""
+    print("测试API客户端结构...")
+    
+    # 测试初始化
+    try:
+        # 应该抛出错误，因为没有API密钥
+        api = NewsSearchAPI()
+        print("警告: API客户端初始化应该失败（无API密钥）")
+    except ValueError as e:
+        print(f"预期错误: {str(e)}")
+    
+    # 测试带API密钥的初始化
+    test_api_key = "test_key_123"
+    api = NewsSearchAPI(api_key=test_api_key)
+    
+    # 检查属性
+    assert api.base_url == "https://openapi.iwencai.com"
+    assert api.endpoint == "/v1/comprehensive/search"
+    assert api.api_key == test_api_key
+    
+    print("API客户端结构测试通过！\n")
+
+
+def test_config_module():
+    """测试配置模块"""
+    print("测试配置模块...")
+    
+    try:
+        from config import Config, get_config
+        
+        # 测试默认配置
+        config = Config()
+        
+        # 检查默认值
+        api_config = config.get_api_config()
+        assert api_config["base_url"] == "https://openapi.iwencai.com"
+        assert api_config["timeout"] == 30
+        
+        search_config = config.get_search_config()
+        assert search_config["default_limit"] == 10
+        assert search_config["default_days"] == 30
+        
+        print("配置模块测试通过！")
+        
+    except ImportError as e:
+        print(f"配置模块导入失败: {str(e)}")
+        print("跳过配置模块测试")
+    
+    print()
+
+
+def run_all_tests():
+    """运行所有测试"""
+    print("=" * 60)
+    print("新闻搜索技能测试套件")
+    print("=" * 60)
+    print()
+    
+    tests = [
+        test_query_processor,
+        test_news_processor,
+        test_api_client_structure,
+        test_config_module,
+    ]
+    
+    passed = 0
+    failed = 0
+    
+    for test_func in tests:
+        try:
+            test_func()
+            passed += 1
+        except AssertionError as e:
+            print(f"测试失败: {str(e)}")
+            failed += 1
+        except Exception as e:
+            print(f"测试异常: {type(e).__name__}: {str(e)}")
+            failed += 1
+    
+    print("=" * 60)
+    print(f"测试结果: 通过 {passed}，失败 {failed}")
+    print("=" * 60)
+    
+    if failed == 0:
+        print("所有测试通过！")
+        return 0
+    else:
+        print(f"{failed} 个测试失败")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(run_all_tests())

Skills/news-search/scripts/test_queries.txt

@@ -0,0 +1,549 @@
+人工智能
+芯片行业
+新能源汽车
+央行货币政策
+腾讯公司
+阿里巴巴
+美团
+京东
+拼多多
+字节跳动
+百度
+华为
+小米
+苹果公司
+特斯拉
+宁德时代
+比亚迪
+隆基绿能
+药明康德
+恒瑞医药
+贵州茅台
+五粮液
+中国平安
+招商银行
+工商银行
+建设银行
+农业银行
+中国银行
+中信证券
+海通证券
+国泰君安
+东方财富
+同花顺
+大智慧
+万得资讯
+金融科技
+数字货币
+区块链
+元宇宙
+5G技术
+6G技术
+云计算
+大数据
+物联网
+工业互联网
+智能制造
+机器人
+自动驾驶
+无人机
+航空航天
+生物医药
+医疗器械
+医疗服务
+健康管理
+养老服务
+教育培训
+在线教育
+职业教育
+文化旅游
+体育产业
+电影产业
+游戏产业
+动漫产业
+短视频
+直播电商
+社交电商
+跨境电商
+物流快递
+共享经济
+新能源
+光伏发电
+风力发电
+水力发电
+核电技术
+储能技术
+氢能源
+碳交易
+碳中和
+环境保护
+污染治理
+垃圾分类
+水资源
+农业科技
+粮食安全
+乡村振兴
+城镇化
+房地产
+基础设施建设
+交通运输
+铁路建设
+公路建设
+机场建设
+港口建设
+一带一路
+京津冀
+长三角
+粤港澳大湾区
+成渝经济圈
+长江经济带
+黄河流域
+东北振兴
+西部开发
+中部崛起
+东部率先
+自由贸易区
+经济特区
+开发区
+高新区
+经开区
+自贸试验区
+综合保税区
+口岸经济
+边境贸易
+国际贸易
+进出口
+外商投资
+对外投资
+国际合作
+全球治理
+世界经济
+国际金融
+国际货币
+汇率变动
+利率政策
+货币政策
+财政政策
+税收政策
+产业政策
+科技政策
+人才政策
+就业政策
+社保政策
+医保政策
+教育政策
+住房政策
+养老政策
+生育政策
+人口政策
+户籍政策
+土地政策
+环保政策
+能源政策
+交通政策
+通信政策
+互联网政策
+数据政策
+人工智能政策
+芯片政策
+新能源汽车政策
+生物医药政策
+金融监管
+证券监管
+银行监管
+保险监管
+支付监管
+反垄断
+反不正当竞争
+消费者权益
+知识产权
+专利保护
+商标保护
+著作权保护
+商业秘密
+网络安全
+数据安全
+个人信息保护
+国家安全
+国防建设
+军队改革
+军民融合
+外交政策
+国际关系
+中美关系
+中欧关系
+中日关系
+中俄关系
+中国东盟关系
+一带一路合作
+金砖国家
+上合组织
+G20峰会
+APEC会议
+达沃斯论坛
+博鳌论坛
+联合国
+世贸组织
+国际货币基金组织
+世界银行
+亚洲开发银行
+亚投行
+新开发银行
+气候变化
+环境保护
+生物多样性
+可持续发展
+减贫脱贫
+共同富裕
+小康社会
+社会主义现代化
+中华民族伟大复兴
+中国梦
+中国共产党
+中国政府
+中国人民
+中国特色社会主义
+改革开放
+市场经济
+计划经济
+混合所有制
+国有企业
+民营企业
+外资企业
+中小企业
+个体工商户
+农民专业合作社
+家庭农场
+农业企业
+工业企业
+服务业企业
+高科技企业
+创新企业
+创业企业
+上市公司
+新三板
+科创板
+创业板
+主板市场
+债券市场
+期货市场
+外汇市场
+黄金市场
+大宗商品
+原油价格
+铁矿石价格
+铜价
+铝价
+锌价
+镍价
+锂价
+钴价
+稀土价格
+粮食价格
+猪肉价格
+蔬菜价格
+水果价格
+房价
+地价
+租金
+工资
+物价
+CPI
+PPI
+GDP
+GNP
+GNI
+财政收入
+财政支出
+财政赤字
+国债
+地方债
+企业债
+公司债
+金融债
+资产证券化
+REITs
+ETF
+LOF
+基金
+股票
+债券
+期货
+期权
+外汇
+黄金
+原油
+数字货币
+比特币
+以太坊
+区块链
+DeFi
+NFT
+Web3
+元宇宙
+人工智能
+机器学习
+深度学习
+自然语言处理
+计算机视觉
+语音识别
+机器人技术
+自动驾驶
+无人机
+智能家居
+智能医疗
+智能教育
+智能交通
+智能城市
+智能制造
+工业互联网
+物联网
+5G
+6G
+卫星互联网
+量子计算
+量子通信
+量子传感
+生物技术
+基因编辑
+细胞治疗
+合成生物学
+生物制药
+医疗器械
+数字医疗
+远程医疗
+互联网医疗
+健康管理
+养老服务
+教育培训
+在线教育
+职业教育
+技能培训
+文化旅游
+体育产业
+电影产业
+游戏产业
+动漫产业
+短视频
+直播
+社交
+电商
+物流
+快递
+外卖
+出行
+住宿
+餐饮
+零售
+批发
+制造
+建筑
+房地产
+金融
+保险
+证券
+银行
+信托
+租赁
+担保
+典当
+拍卖
+评估
+会计
+审计
+税务
+法律
+咨询
+设计
+研发
+测试
+运维
+运营
+市场
+销售
+客服
+人力资源
+行政
+财务
+采购
+生产
+质量
+安全
+环保
+能源
+交通
+通信
+IT
+互联网
+软件
+硬件
+芯片
+半导体
+显示面板
+电池
+电机
+电控
+汽车
+飞机
+船舶
+火车
+地铁
+公交
+出租车
+共享单车
+共享汽车
+物流车
+货车
+客车
+轿车
+SUV
+MPV
+电动车
+混动车
+燃油车
+氢燃料车
+太阳能车
+飞行汽车
+无人机配送
+机器人配送
+智���仓储
+智能物流
+智慧港口
+智慧机场
+智慧车站
+智慧公路
+智慧铁路
+智慧地铁
+智慧公交
+智慧出租车
+智慧停车
+智慧交通
+智慧城市
+智慧社区
+智慧家庭
+智慧办公
+智慧工厂
+智慧农场
+智慧医院
+智慧学校
+智慧政府
+智慧法院
+智慧检察院
+智慧公安
+智慧消防
+智慧应急
+智慧环保
+智慧能源
+智慧水利
+智慧林业
+智慧草原
+智慧海洋
+智慧天空
+智慧地球
+数字地球
+元宇宙地球
+虚拟现实
+增强现实
+混合现实
+扩展现实
+脑机接口
+人机交互
+语音交互
+手势交互
+眼动交互
+脑电交互
+肌电交互
+心电交互
+血压监测
+血糖监测
+血氧监测
+体温监测
+呼吸监测
+心率监测
+睡眠监测
+运动监测
+饮食监测
+情绪监测
+压力监测
+疲劳监测
+健康评估
+疾病预测
+早期筛查
+精准诊断
+个性化治疗
+康复训练
+长期照护
+临终关怀
+生命科学
+医学研究
+药物研发
+临床试验
+药品生产
+药品流通
+药品使用
+药品监管
+医疗器械研发
+医疗器械生产
+医疗器械流通
+医疗器械使用
+医疗器械监管
+医疗服务提供
+医疗服务支付
+医疗服务监管
+医疗数据管理
+医疗信息安全
+医疗人工智能
+医疗机器人
+医疗3D打印
+医疗VR/AR
+医疗物联网
+医疗区块链
+医疗云计算
+医疗大数据
+医疗5G
+远程手术
+远程会诊
+远程监护
+远程康复
+互联网医院
+数字医院
+智慧医院
+未来医院
+健康中国
+美丽中国
+平安中国
+法治中国
+数字中国
+创新中国
+科技强国
+制造强国
+质量强国
+网络强国
+交通强国
+海洋强国
+航天强国
+文化强国
+教育强国
+人才强国
+体育强国
+健康强国
+平安强国
+法治强国
+数字强国
+创新强国
+科技兴国
+制造兴国
+质量兴国
+网络兴国
+交通兴国
+海洋兴国
+航天兴国
+文化兴国
+教育兴国
+人才兴国
+体育兴国
+健康兴国
+平安兴国
+法治兴国
+数字兴国
+创新兴国

Skills/report-search/README.md

@@ -0,0 +1,280 @@
+# 研报搜索技能
+
+财经研究报告搜索引擎，调用同花顺问财的财经资讯搜索接口，专门搜索和分析主流投研机构发布的研究报告。
+
+## 功能特点
+
+- **研究报告搜索**: 专门搜索各类财经研究报告和分析文章
+- **专业查询处理**: 自动拆解复杂查询为多个专业查询，生成标准化关键词
+- **数据质量评估**: 自动评估搜索结果的专业性和完整性
+- **关键信息提取**: 提取分析逻辑、投资评级、目标价等关键信息
+- **多种输出格式**: 支持CSV、JSON、Markdown等多种输出格式
+- **批量处理**: 支持从文件读取多个查询并批量处理
+- **错误处理**: 完善的错误处理和重试机制
+- **详细日志**: 详细的运行日志和调试信息
+- **跨平台支持**: 支持Windows、macOS、Linux操作系统
+- **规范遵守**: 符合iwencai-skill-creator所有规范要求
+- **响应透明传递**: 严格遵循iwencai-gateway-spec规范，API响应透明传递给调用方
+
+## 响应透明传递规范
+
+本技能严格遵循iwencai-gateway-spec规范，特别是**响应透明传递要求**：
+
+### 核心原则
+- **禁止对API响应进行任何修改**：不得对网关返回的`data`、`result`、`response`等字段进行二次解析、清洗、重组
+- **直接透传完整响应**：API客户端返回完整的HTTP响应体，原封不动传递给调用方
+- **错误透明传递**：API返回的错误状态码与错误Body也应完整传递，不得替换为自定义错误信息
+
+### 使用说明
+1. **AI代理调用时**：必须使用`api_client.py`模块，保持响应透明传递
+2. **CLI工具使用时**：可以使用`data_processor.py`进行用户界面友好的后处理
+3. **代码生成时**：优先展示透明传递的API调用方式
+
+### 违规示例（禁止）
+```python
+# ❌ 违规：对API响应做了二次组装
+def call_api(...):
+    resp = requests.post(url, headers=headers, json=payload)
+    data = resp.json()
+    result = {"code": 0, "data": data["result"], "msg": "success"}  # 禁止：自行包装
+    return result
+```
+
+### 合规示例（推荐）
+```python
+# ✅ 合规：透明传递API响应
+def call_api(...):
+    resp = requests.post(url, headers=headers, json=payload)
+    return resp  # 或 return resp.json() 直接返回原始响应
+```
+
+## 安装要求
+
+- Python 3.7+
+- requests库（通过requirements.txt安装）
+
+## 快速开始
+
+### 1. 获取API密钥
+
+所有技能都需要 IWENCAI_API_KEY 环境变量才能使用。如果用户尚未配置，按以下步骤引导：
+
+步骤 1：获取 API Key
+在浏览器内打同花顺i问财SkillHub页面：https://www.iwencai.com/skillhub
+
+步骤 2：登录
+
+步骤 3：点击具体的Skill，打开弹窗查看详情，在安装方式-Agent用户-找到您的IWENCAI_API_KEY这一段，复制
+
+步骤 4：配置环境变量
+获取到 API Key 后，直接复制指引文字发送给AI助手，或手动设置环境变量：
+
+### 2. 设置环境变量
+
+#### Unix/Linux/macOS (bash/zsh)
+```bash
+export IWENCAI_API_KEY="your_api_key_here"
+```
+
+#### Windows PowerShell
+```powershell
+$env:IWENCAI_API_KEY="your_api_key_here"
+```
+
+#### Windows CMD
+```cmd
+set IWENCAI_API_KEY=your_api_key_here
+```
+
+### 3. 安装依赖
+```bash
+pip install -r requirements.txt
+```
+
+### 4. 基本使用
+
+```bash
+# 搜索研究报告
+python research_report_search.py -q "人工智能行业研究报告"
+
+# 搜索最近30天的研究报告
+python research_report_search.py -q "芯片行业" -d 30
+
+# 限制返回结果数量
+python research_report_search.py -q "新能源汽车" -l 5
+
+# 导出为CSV格式
+python research_report_search.py -q "人工智能" -o results.csv -f csv
+
+# 导出为JSON格式
+python research_report_search.py -q "人工智能" -o results.json -f json
+
+# 导出为Markdown报告格式
+python research_report_search.py -q "医药行业" -o report.md -f markdown
+```
+
+### 5. 测试API连接
+```bash
+python research_report_search.py --test
+```
+
+### 6. curl示例
+```bash
+# 使用环境变量中的 API Key
+curl -X POST "https://openapi.iwencai.com/v1/comprehensive/search" \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $IWENCAI_API_KEY" \
+  -H "X-Claw-Call-Type: normal" \
+  -H "X-Claw-Skill-Id: report-search" \
+  -H "X-Claw-Skill-Version: 2.0.0" \
+  -H "X-Claw-Plugin-Id: none" \
+  -H "X-Claw-Plugin-Version: none" \
+  -H "X-Claw-Trace-Id: $(python -c 'import secrets; print(secrets.token_hex(32))')" \
+  -d '{
+    "channels": ["report"],
+    "app_id": "AIME_SKILL",
+    "query": "人工智能行业研究报告"
+  }'
+```
+
+## 批量处理
+
+```bash
+# 从文件读取多个查询并批量处理
+python research_report_search.py -i queries.txt -o ./results
+
+# 指定输出格式为JSON
+python research_report_search.py -i queries.txt -o ./results -f json
+```
+
+## 时间范围搜索
+
+```bash
+# 搜索指定时间范围的研究报告
+python research_report_search.py -q "新能源车" --date-from "2024-01-01" --date-to "2024-03-31"
+
+# 搜索最近7天的研究报告
+python research_report_search.py -q "人工智能" -d 7
+```
+
+## 命令行参数
+
+### 基本搜索参数
+- `-q, --query`: 搜索关键词（支持中文）
+- `-o, --output`: 输出文件路径
+- `-f, --format`: 输出格式（csv, json, text, markdown）
+- `-l, --limit`: 结果数量限制（默认10）
+
+### 批量处理参数
+- `-i, --input`: 输入文件路径（支持批量查询）
+- `--input-format`: 输入文件格式（txt, csv, json）
+- `--output-dir`: 输出目录（批量处理时使用）
+
+### 过滤与排序参数
+- `--date-from`: 开始日期（YYYY-MM-DD）
+- `--date-to`: 结束日期（YYYY-MM-DD）
+- `-d, --days`: 最近N天（与date-from/date-to互斥）
+- `--sort-by`: 排序字段（date, relevance）
+- `--sort-order`: 排序顺序（asc, desc）
+
+### 其他参数
+- `-v, --verbose`: 详细输出模式
+- `--debug`: 调试模式
+- `--test`: 测试API连接
+- `--config`: 配置文件路径
+- `-h, --help`: 显示帮助信息
+
+## 配置文件
+
+技能使用 `config.example.json` 作为配置文件示例，实际配置应通过环境变量或自定义配置文件设置。
+
+### 配置示例 (config.example.json)
+```json
+{
+  "api": {
+    "base_url": "https://openapi.iwencai.com",
+    "endpoint": "/v1/comprehensive/search",
+    "timeout": 30,
+    "max_retries": 3,
+    "retry_delay": 1.0
+  },
+  "search": {
+    "channels": ["report"],
+    "app_id": "AIME_SKILL",
+    "default_limit": 10,
+    "default_days": 30,
+    "min_articles_for_sufficient": 3
+  },
+  "output": {
+    "default_format": "text",
+    "csv_encoding": "utf-8-sig",
+    "json_indent": 2
+  },
+  "logging": {
+    "level": "INFO",
+    "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+  },
+  "注意": "API密钥应从环境变量 IWENCAI_API_KEY 获取，不要在此配置文件中硬编码"
+}
+```
+
+## 使用示例
+
+### 示例1：基本搜索
+```bash
+python research_report_search.py --query "人工智能行业研究报告" --output ai_reports.csv --format csv
+```
+
+### 示例2：批量处理
+```bash
+# queries.txt 内容：
+# 人工智能
+# 芯片行业
+# 新能源汽车
+# 医药行业
+
+python research_report_search.py --input queries.txt --output-dir ./reports --format json
+```
+
+### 示例3：专业分析报告
+```bash
+python research_report_search.py --query "特斯拉投资评级目标价" --output tesla_analysis.md --format markdown --limit 5
+```
+
+### 示例4：时间范围搜索
+```bash
+python research_report_search.py --query "央行货币政策" --date-from "2024-01-01" --date-to "2024-03-31" --output monetary_policy.json --format json
+```
+
+## 接口规范
+
+本技能严格遵守iwencai-skill-creator规范，所有发往问财 OpenAPI 网关的请求包含以下 Header：
+
+| Header | 取值说明 |
+|--------|----------|
+| `X-Claw-Call-Type` | `normal`：正常请求；`retry`：失败后的重试 |
+| `X-Claw-Skill-Id` | 技能标识：`report-search` |
+| `X-Claw-Skill-Version` | 技能版本：`2.0.0` |
+| `X-Claw-Plugin-Id` | 插件 ID：`none` |
+| `X-Claw-Plugin-Version` | 插件版本：`none` |
+| `X-Claw-Trace-Id` | **每次请求必须新生成**的**全局唯一**追踪 ID；**长度为 64 个字符** |
+
+## 注意事项
+
+1. **API密钥安全**: API密钥必须通过环境变量设置，不要硬编码在代码中
+2. **认证方式**: 必须使用Bearer Token认证方式
+3. **规范遵守**: 必须遵守iwencai-skill-creator的所有规范要求
+4. **使用限制**: 遵守接口调用频率限制
+5. **错误处理**: 技能包含完善的错误处理和重试机制
+7. **跨平台支持**: 支持Windows、macOS、Linux操作系统
+
+## 技术支持
+
+如有问题，请参考：
+- `SKILL.md`: 技能详细说明文档
+- `references/api.md`: 接口文档
+- 示例代码：`scripts/example_usage.py`
+
+---
+版本：2.0.0
+更新日期：2026-04-17

Skills/report-search/SKILL.md

@@ -0,0 +1,321 @@
+---
+name: report-search
+description: 收录了主流投研机构发布的研究报告，帮你快速获取专业、深度的分析逻辑、投资评级、目标价等重要投研决策信息。
+version: 1.0.0
+---
+
+# 研报搜索技能
+
+## 版本
+当前技能版本：1.0.0（与X-Claw-Skill-Version头一致）
+
+## 首次使用 - 获取 API Key
+所有技能都需要 IWENCAI_API_KEY 环境变量才能使用。 如果用户尚未配置，按以下步骤引导：
+
+步骤 1：获取 API Key
+在浏览器内打同花顺i问财SkillHub页面：https://www.iwencai.com/skillhub
+
+步骤 2：登录
+
+步骤 3：点击具体的Skill，打开弹窗查看详情，在安装方式-Agent用户-找到您的IWENCAI_API_KEY这一段，复制
+
+步骤 4：配置环境变量
+获取到 API Key 后，直接复制指引文字发送给AI助手，或手动设置环境变量：
+
+## 技能概述
+
+本技能是一个财经研究报告搜索引擎，通过调用同花顺问财的财经资讯搜索接口，专门搜索和分析主流投研机构发布的研究报告，帮助用户获取专业的分析逻辑、投资评级、目标价等重要投研决策信息。本技能符合iwencai-skill-creator规范，确保所有API调用遵循问财OpenAPI网关的标准要求。
+
+## 技能功能
+
+### 1. 研究报告搜索
+- 搜索各类财经研究报告和分析文章
+- 覆盖主流投研机构、证券公司、研究机构等
+- 支持中文关键词搜索，专注于研究报告类型
+- 符合iwencai-gateway-spec规范，包含完整的X-Claw-* Header
+
+### 2. 智能查询处理能力
+- 自动拆解复杂查询为多个专业查询
+- 示例：用户问"人工智能和芯片行业的研究报告"可以拆分为"人工智能行业研究报告"和"芯片行业研究报告"
+- 根据查询复杂度决定调用接口的次数
+- 生成标准化的专业查询关键词
+
+### 3. 数据质量评估与扩展
+- 自动评估搜索结果的专业性和相关性
+- 检查研究报告是否包含分析逻辑、投资评级、目标价等关键信息
+- 如有必要，可调用其他技能或工具扩展数据源
+- 对搜索结果进行专业质量评估
+
+### 4. 专业数据处理与返回
+- 对研究搜索结果进行专业排序、过滤和摘要
+- 提取关键信息：分析逻辑、投资评级、目标价、风险提示等
+- **⚠️ 重要警告：根据问财OpenAPI网关规范条件六，API原始响应必须透明传递**
+- **必须遵守**：不得对API响应进行二次解析、清洗、重组或再加工
+- **透明传递要求**：
+  - 直接返回API原始响应JSON，不做任何包装
+  - 错误响应也必须原样传递，不得替换为自定义错误信息
+  - 网络层错误（超时、连接失败等）可提供技术性错误信息
+- 将透明传递的响应数据返回给大模型进行处理
+- 大模型负责生成专业、深度的回答格式
+
+## 接口规范
+
+### HTTP Header 要求
+所有发往问财 OpenAPI 网关的请求必须包含以下 Header：
+
+| Header | 取值说明 |
+|--------|----------|
+| `X-Claw-Call-Type` | `normal`：正常请求；`retry`：失败后的重试。按实际调用场景二选一。 |
+| `X-Claw-Skill-Id` | 技能标识，固定为 `report-search`。 |
+| `X-Claw-Skill-Version` | 当前技能版本号，固定为 `1.0.0`。 |
+| `X-Claw-Plugin-Id` | 插件 ID，固定为 `none`。 |
+| `X-Claw-Plugin-Version` | 插件版本，固定为 `none`。 |
+| `X-Claw-Trace-Id` | **每次请求必须新生成**的**全局唯一**追踪 ID；**长度为 64 个字符**（使用 64 位十六进制字符串）。 |
+
+### 基础信息
+- **Base URL**: `https://openapi.iwencai.com`
+- **接口路径**: `/v1/comprehensive/search`
+- **请求方式**: POST（优先使用 POST）
+- **认证方式**: API Key (Bearer Token)
+
+### 认证要求
+在请求头中需要携带API Key进行认证：
+```
+Authorization: Bearer {IWENCAI_API_KEY}
+```
+其中 `IWENCAI_API_KEY` 是用户申请的有效API密钥，需要设置为环境变量。
+
+### 请求参数
+```json
+{
+  "channels": ["report"],
+  "app_id": "AIME_SKILL",
+  "query": "搜索关键词"
+}
+```
+
+**重要参数说明**：
+- `channels`: 固定为 `["report"]`，表示搜索研究报告类型
+- `app_id`: 固定为 `AIME_SKILL`
+- `query`: 用户搜索关键词，支持中文
+
+### 响应透明传递要求（Non-Negotiable）
+**核心原则：Skill 生成的代码必须透明传递 API 响应，不得对返回内容做任何修改、过滤、重组或再加工后再交付给调用方。**
+
+1. **禁止行为**：
+   - 不得对网关返回的 `data`、`result`、`response` 等字段进行二次解析、清洗、重组；
+   - 不得自行添加、删除、修改返回结果的任何键值或结构；
+   - 不得在 Skill 生成的代码中将 API 原始响应包装成另一套 `result` / `output` / `data` 等结构再返回；
+   - 不得在返回前对响应内容做任何「业务逻辑层」的处理（如字段映射、类型转换、格式化等），这些应由调用方决定如何处理。
+
+2. **要求行为**：
+   - **直接透传**：对网关返回的完整 HTTP 响应体（Body），应在获取后**原封不动**地传递给调用方（或返回给 LLM）；
+   - **透明返回**：若使用 Python 等语言实现，返回值应为对 API 响应的直接赋值或简单的 `return response`，不做任何中间 transformation；
+   - **错误传递**：API 返回的错误状态码与错误 Body 也应完整传递，不得替换为自定义错误信息（除非是网络层超时、连接失败等技术性错误）。
+
+3. **正确实现示例**：
+```python
+# ✅ 正确：直接返回API响应
+def search_reports(query: str):
+    response = requests.post(url, headers=headers, json=payload)
+    # 直接返回API响应，不做任何处理
+    return response.json()
+```
+
+4. **错误实现示例**：
+```python
+# ❌ 错误：对API响应做了二次组装
+def search_reports(query: str):
+    resp = requests.post(url, headers=headers, json=payload)
+    data = resp.json()
+    result = {"code": 0, "data": data["result"], "msg": "success"}  # 禁止：自行包装
+    return result
+```
+
+## 使用说明
+
+### 环境变量配置
+
+#### Unix/Linux/macOS (bash/zsh)
+```bash
+export IWENCAI_API_KEY="your_api_key_here"
+```
+
+#### Windows PowerShell
+```powershell
+$env:IWENCAI_API_KEY="your_api_key_here"
+```
+
+#### Windows CMD
+```cmd
+set IWENCAI_API_KEY=your_api_key_here
+```
+
+### 命令行使用
+```bash
+# 基本搜索
+python research_report_search.py -q "人工智能行业研究报告"
+
+# 限制结果数量
+python research_report_search.py -q "芯片行业" -l 5
+
+# 导出为CSV格式
+python research_report_search.py -q "新能源汽车" -o results.csv -f csv
+
+# 批量处理
+python research_report_search.py -i queries.txt -o ./results -f json
+
+# 时间范围搜索
+python research_report_search.py -q "医药行业" --date-from "2024-01-01" --date-to "2024-03-31"
+
+# 获取帮助
+python research_report_search.py -h
+```
+
+### curl 示例
+```bash
+# 生成64位十六进制Trace ID
+TRACE_ID=$(python3 -c "import secrets; print(secrets.token_hex(32))")
+
+# 使用环境变量中的 API Key
+curl -X POST "https://openapi.iwencai.com/v1/comprehensive/search" \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $IWENCAI_API_KEY" \
+  -H "X-Claw-Call-Type: normal" \
+  -H "X-Claw-Skill-Id: report-search" \
+  -H "X-Claw-Skill-Version: 1.0.0" \
+  -H "X-Claw-Plugin-Id: none" \
+  -H "X-Claw-Plugin-Version: none" \
+  -H "X-Claw-Trace-Id: $TRACE_ID" \
+  -d '{
+    "channels": ["report"],
+    "app_id": "AIME_SKILL",
+    "query": "人工智能行业研究报告"
+  }'
+```
+
+**Windows PowerShell 示例：**
+```powershell
+# 生成64位十六进制Trace ID
+$TRACE_ID = python -c "import secrets; print(secrets.token_hex(32))"
+
+# 调用研报搜索接口
+$headers = @{
+    "Content-Type" = "application/json"
+    "Authorization" = "Bearer $env:IWENCAI_API_KEY"
+    "X-Claw-Call-Type" = "normal"
+    "X-Claw-Skill-Id" = "report-search"
+    "X-Claw-Skill-Version" = "1.0.0"
+    "X-Claw-Plugin-Id" = "none"
+    "X-Claw-Plugin-Version" = "none"
+    "X-Claw-Trace-Id" = $TRACE_ID
+}
+
+$body = @{
+    channels = @("report")
+    app_id = "AIME_SKILL"
+    query = "人工智能行业研究报告"
+} | ConvertTo-Json
+
+Invoke-RestMethod -Uri "https://openapi.iwencai.com/v1/comprehensive/search" -Method Post -Headers $headers -Body $body
+```
+
+## 使用场景
+
+### 何时调用本技能
+1. **行业研究报告搜索**: 当用户需要了解特定行业的专业研究报告时
+2. **公司分析报告查询**: 当用户需要获取特定公司的深度分析报告时
+3. **投资评级查询**: 当用户需要了解投资评级和目标价信息时
+4. **趋势分析报告**: 当用户需要获取行业趋势和专业分析时
+5. **投研决策支持**: 当用户需要专业投研信息支持决策时
+
+### 调用示例
+1. 用户问："人工智能行业的最新研究报告有哪些？"
+2. 用户问："特斯拉的投资评级和目标价是多少？"
+3. 用户问："芯片行业的深度分析报告有哪些？"
+4. 用户问："新能源车行业的投资前景分析报告？"
+5. 用户问："医药行业的研究报告和投资建议？"
+
+## 技能内部逻辑
+
+### 查询处理流程
+1. **接收用户查询**: 获取用户的专业搜索需求
+2. **查询拆解分析**: 分析查询复杂度，决定是否需要拆分为多个专业子查询
+3. **专业查询生成**: 生成标准化的专业查询关键词，优化搜索效果
+4. **API调用执行**: 生成并执行API调用代码，使用Bearer Token认证和X-Claw-* Header
+5. **数据质量评估**: 检查返回的研究报告是否专业、完整，能否回答用户问题
+6. **专业数据处理**: 对搜索结果进行专业排序、过滤、摘要和关键信息提取
+7. **结果整合返回**: 将处理后的专业结果返回给大模型，生成深度回答
+
+### 代码生成要求
+- 生成完整的API调用代码，包括Bearer Token认证、X-Claw-* Header、64字符Trace ID
+- 处理网络异常和接口错误，实现专业重试机制
+- **严格遵守响应透明传递要求**：返回完整的API响应，不得对响应内容做任何修改、过滤、重组
+- 确保代码符合Python最佳实践，可读性和可维护性高
+- **注意**：仅在用户明确要求进行数据处理时，才在返回给用户前进行适当的格式化展示，但API调用本身必须保持透明传递
+
+## 技术实现
+
+### Python代码要求
+- 使用Python 3.7+版本
+- 优先使用Python标准库和官方包
+- 常用库允许使用：requests, pandas, numpy等
+- 尽量减少第三方库依赖
+- 代码结构清晰，模块化设计
+
+### 配置文件要求
+- 必须包含 `config.example.json` 配置文件示例
+- 必须实现 `config.py` 配置管理模块
+- API密钥必须从环境变量 `IWENCAI_API_KEY` 获取，不得硬编码
+
+### 目录结构要求
+```
+研报搜索/
+├── README.md              # 技能说明文档（中文）
+├── SKILL.md              # 技能主文档（包含YAML frontmatter）
+├── references/           # 参考文档目录
+│   └── api.md           # 接口文档副本
+└── scripts/             # 源代码目录
+    ├── __main__.py      # 命令行入口点
+    ├── config.py        # 配置管理模块
+    ├── config.example.json # 配置文件示例
+    ├── requirements.txt # Python依赖文件
+    ├── setup.py         # 安装配置
+    ├── research_report_search.py # 主程序文件
+    ├── api_client.py    # API客户端模块
+    ├── data_processor.py # 数据处理模块
+    ├── cli.py           # CLI接口模块
+    ├── example_usage.py # 使用示例
+    └── test_basic.py    # 基础测试
+```
+
+### CLI接口要求
+- 支持 `python research_report_search.py` 调用方式
+- 支持 `python -m scripts.research_report_search` 调用方式
+- 提供完整的命令行参数和帮助文档
+- 支持多种输出格式：csv, json, text, markdown
+
+### API透明传递与CLI数据处理区分说明
+1. **API客户端模块 (api_client.py)**：
+   - 严格遵守响应透明传递要求，返回完整的API响应
+   - 不进行任何数据清洗、重组或业务逻辑处理
+   - 仅处理网络层错误和认证问题
+
+2. **CLI工具与数据处理模块 (cli.py, data_processor.py)**：
+   - 这些模块仅用于命令行工具的后处理功能
+   - 当使用CLI工具时，可以对API响应进行格式化、过滤等用户界面友好的处理
+   - 但在技能被AI调用时，必须使用API客户端模块的透明传递方式
+
+3. **重要原则**：
+   - 当技能被AI代理调用时，必须生成使用api_client.py的代码，并保持响应透明传递
+   - 当用户直接使用CLI工具时，可以使用data_processor.py进行后处理
+   - SKILL.md中的代码示例应优先展示透明传递的API调用方式
+
+## 注意事项
+
+1. **数据专业性**: 专注于研究报告类型，确保返回结果的深度和专业性
+2. **认证合规**: 必须使用Bearer Token认证方式，符合公网访问要求
+3. **错误处理**: 实现完善的错误处理和重试机制
+4. **性能优化**: 考虑接口调用频率限制，实现合理的请求间隔
+5. **用户体验**: CLI接口要直观易用，提供清晰的专业反馈
+6. **规范遵守**: 必须遵守iwencai-skill-creator的所有规范要求

Skills/report-search/references/api.md

@@ -0,0 +1,235 @@
+# 财经报告搜索接口文档
+
+## 接口概述
+
+- **接口名称**: 财经报告搜索接口
+- **接口说明**: 搜索财经领域的报告文章，返回相关的文章信息列表
+- **接口版本**: v1
+
+## 基础信息
+
+- **Base URL**: `https://openapi.iwencai.com`
+- **接口路径**: `/v1/comprehensive/search`
+- **请求方式**: POST
+- **Content-Type**: `application/json`
+- **API Key 环境变量**: `IWENCAI_API_KEY`
+
+## 请求说明
+
+### 请求头
+
+```
+Content-Type: application/json
+```
+
+### 请求参数
+
+请求体为 JSON 格式，包含以下参数：
+
+#### 固定参数
+
+| 参数名 | 类型 | 说明 | 值 |
+|--------|------|------|-----|
+| channels | LIST | 搜索渠道类型 | `["report"]` |
+| app_id | STRING | 应用ID | `AIME_SKILL` |
+
+#### 可变参数
+
+| 参数名 | 类型 | 说明 | 必填 |
+|--------|------|------|------|
+| query | STRING | 用户问句，即搜索关键词 | 是 |
+
+### 请求示例
+
+```json
+{
+  "channels": ["report"],
+  "app_id": "AIME_SKILL",
+  "query": "人工智能行业研究报告"
+}
+```
+
+## 响应说明
+
+### 响应格式
+
+响应为 JSON 格式，主要包含 `data` 字段，该字段是一个文章信息列表。
+
+### 响应结构
+
+```json
+{
+  "data": [
+    {
+      "title": "文章标题",
+      "summary": "文章摘要",
+      "url": "文章网址",
+      "publish_date": "文章发布时间"
+    }
+  ]
+}
+```
+
+### 字段说明
+
+#### data 字段
+
+| 字段名 | 类型 | 说明 | 格式 |
+|--------|------|------|------|
+| title | STRING | 文章标题 | - |
+| summary | STRING | 文章摘要 | - |
+| url | STRING | 文章网址 | URL格式 |
+| publish_date | STRING | 文章发布时间 | `YYYY-MM-DD HH:MM:SS` |
+
+### 响应示例
+
+```json
+{
+  "data": [
+    {
+      "title": "2024年人工智能行业发展趋势报告",
+      "summary": "本报告分析了2024年人工智能行业的发展趋势，包括技术突破、应用场景、市场规模等方面的内容...",
+      "url": "https://example.com/reports/ai-trends-2024",
+      "publish_date": "2024-01-15 09:30:00"
+    },
+    {
+      "title": "金融科技AI应用研究报告",
+      "summary": "报告详细介绍了人工智能在金融科技领域的应用现状和未来发展方向...",
+      "url": "https://example.com/reports/fintech-ai-applications",
+      "publish_date": "2024-01-14 14:20:00"
+    },
+    {
+      "title": "智能制造AI解决方案分析",
+      "summary": "本报告分析了人工智能在智能制造领域的解决方案和应用案例...",
+      "url": "https://example.com/reports/smart-manufacturing-ai",
+      "publish_date": "2024-01-13 11:15"
+    }
+  ]
+}
+```
+
+## 使用说明
+
+### 环境变量设置
+
+在使用此接口前，需要设置 API Key 环境变量：
+
+```bash
+export IWENCAI_API_KEY="your_api_key_here"
+```
+
+### 调用示例（Python）
+
+```python
+import os
+import requests
+import json
+
+# API配置
+BASE_URL = "https://openapi.iwencai.com"
+ENDPOINT = "/v1/comprehensive/search"
+API_KEY = os.getenv("IWENCAI_API_KEY")
+
+# 请求头
+headers = {
+    "Content-Type": "application/json",
+    "Authorization": f"Bearer {API_KEY}"
+}
+
+# 请求体
+payload = {
+    "channels": ["report"],
+    "app_id": "AIME_SKILL",
+    "query": "人工智能行业研究报告"
+}
+
+# 发送请求
+response = requests.post(
+    f"{BASE_URL}{ENDPOINT}",
+    headers=headers,
+    json=payload
+)
+
+# 处理响应
+if response.status_code == 200:
+    data = response.json()
+    articles = data.get("data", [])
+    for article in articles:
+        print(f"标题: {article['title']}")
+        print(f"摘要: {article['summary']}")
+        print(f"链接: {article['url']}")
+        print(f"发布时间: {article['publish_date']}")
+        print("---")
+else:
+    print(f"请求失败: {response.status_code}")
+    print(response.text)
+```
+
+### 调用示例（JavaScript/Node.js）
+
+```javascript
+const axios = require('axios');
+
+// API配置
+const BASE_URL = 'https://openapi.iwencai.com';
+const ENDPOINT = '/v1/comprehensive/search';
+const API_KEY = process.env.IWENCAI_API_KEY;
+
+// 请求头
+const headers = {
+  'Content-Type': 'application/json',
+  'Authorization': `Bearer ${API_KEY}`
+};
+
+// 请求体
+const payload = {
+  channels: ['report'],
+  app_id: 'AIME_SKILL',
+  query: '人工智能行业研究报告'
+};
+
+// 发送请求
+axios.post(`${BASE_URL}${ENDPOINT}`, payload, { headers })
+  .then(response => {
+    const articles = response.data.data || [];
+    articles.forEach(article => {
+      console.log(`标题: ${article.title}`);
+      console.log(`摘要: ${article.summary}`);
+      console.log(`链接: ${article.url}`);
+      console.log(`发布时间: ${article.publish_date}`);
+      console.log('---');
+    });
+  })
+  .catch(error => {
+    console.error('请求失败:', error.response?.status || error.message);
+    console.error('错误信息:', error.response?.data || error.message);
+  });
+```
+
+## 注意事项
+
+1. **API Key**: 需要申请有效的 API Key 并设置为 `IWENCAI_API_KEY` 环境变量
+2. **参数固定值**: `channels` 参数必须为 `["report"]`，`app_id` 参数必须为 `AIME_SKILL`
+3. **搜索关键词**: `query` 参数支持中文关键词，建议使用具体的搜索词以获得更准确的结果
+4. **响应数据**: 返回的文章数据按发布时间倒序排列
+5. **错误处理**: 如果请求失败，请检查网络连接、API Key 和请求参数
+
+## 常见问题
+
+### Q: 如何获取 API Key？
+A: 需要向接口提供方申请有效的 API Key。
+
+### Q: 搜索不到结果怎么办？
+A: 可以尝试调整搜索关键词，使用更具体或更通用的词汇。
+
+### Q: 返回的文章数量有限制吗？
+A: 接口文档未明确说明返回数量限制，实际返回数量可能受搜索条件和系统限制影响。
+
+### Q: publish_date 字段的时区是什么？
+A: 文档未明确说明时区，通常为北京时间（UTC+8）。
+
+---
+
+**文档版本**: 1.0  
+**最后更新**: 基于 api_prompt.txt 生成  
+**接口状态**: 正常

Skills/report-search/scripts/__main__.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+研报搜索技能命令行入口点
+"""
+
+import sys
+import os
+
+# 添加当前目录到Python路径
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from research_report_search import main
+
+if __name__ == "__main__":
+    sys.exit(main())

Skills/report-search/scripts/api_client.py

@@ -0,0 +1,261 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+研报搜索技能API客户端模块
+符合iwencai-skill-creator规范
+"""
+
+import json
+import time
+import logging
+import secrets
+from typing import Dict, List, Any, Optional, Tuple
+import requests
+from requests.exceptions import RequestException, Timeout, ConnectionError
+
+from config import get_config
+
+
+class APIError(Exception):
+    """API错误异常类"""
+    pass
+
+
+class APIClient:
+    """API客户端类"""
+    
+    def __init__(self, config_file: Optional[str] = None):
+        """
+        初始化API客户端
+        
+        Args:
+            config_file: 配置文件路径
+        """
+        self.config = get_config(config_file)
+        self.api_url = self.config.get_api_url()
+        self.api_key = self.config.get_api_key()
+        self.timeout = self.config.get("api.timeout")
+        self.max_retries = self.config.get("api.max_retries")
+        self.retry_delay = self.config.get("api.retry_delay")
+        self.skill_id = "report-search"
+        self.skill_version = "2.0.0"
+        
+        # 设置日志
+        self.config.setup_logging()
+        self.logger = logging.getLogger(__name__)
+    
+    def _generate_trace_id(self) -> str:
+        """生成64字符的Trace ID"""
+        return secrets.token_hex(32)
+    
+    def _get_headers(self, call_type: str = "normal") -> Dict[str, str]:
+        """获取请求头（包含X-Claw-* Header）"""
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+            "X-Claw-Call-Type": call_type,
+            "X-Claw-Skill-Id": self.skill_id,
+            "X-Claw-Skill-Version": self.skill_version,
+            "X-Claw-Plugin-Id": "none",
+            "X-Claw-Plugin-Version": "none",
+            "X-Claw-Trace-Id": self._generate_trace_id()
+        }
+        return headers
+    
+    def _prepare_payload(self, query: str, limit: Optional[int] = None) -> Dict[str, Any]:
+        """准备请求体"""
+        payload = {
+            "channels": self.config.get("search.channels"),
+            "app_id": self.config.get("search.app_id"),
+            "query": query
+        }
+        
+        # 可以添加其他参数
+        if limit:
+            # 注意：实际接口可能不支持limit参数，这里只是示例
+            pass
+        
+        return payload
+    
+    def _make_request_raw(self, payload: Dict[str, Any], call_type: str = "normal") -> Dict[str, Any]:
+        """
+        发送请求（带重试机制，完全透明传递响应）
+        
+        根据问财OpenAPI网关规范条件六，此方法必须透明传递所有API响应，
+        包括错误响应，不做任何修改、过滤或重组。
+        """
+        for attempt in range(self.max_retries + 1):
+            try:
+                headers = self._get_headers(call_type)
+                
+                self.logger.debug(f"发送API请求 (尝试 {attempt + 1}/{self.max_retries + 1}): {payload}")
+                self.logger.debug(f"Trace ID: {headers['X-Claw-Trace-Id']}")
+                
+                response = requests.post(
+                    self.api_url,
+                    headers=headers,
+                    json=payload,
+                    timeout=self.timeout
+                )
+                
+                self.logger.debug(f"API响应状态码: {response.status_code}")
+                
+                try:
+                    return response.json()
+                except ValueError:
+                    self.logger.warning(f"API返回非JSON响应，状态码: {response.status_code}")
+                    return {
+                        "error": "invalid_json_response",
+                        "raw_response": response.text,
+                        "status_code": response.status_code,
+                        "headers": dict(response.headers)
+                    }
+                    
+            except Timeout:
+                self.logger.warning(f"请求超时 (尝试 {attempt + 1}/{self.max_retries + 1})")
+                if attempt < self.max_retries:
+                    wait_time = self.retry_delay * (attempt + 1)
+                    self.logger.info(f"等待 {wait_time} 秒后重试...")
+                    time.sleep(wait_time)
+                else:
+                    raise
+                    
+            except ConnectionError:
+                self.logger.warning(f"连接错误 (尝试 {attempt + 1}/{self.max_retries + 1})")
+                if attempt < self.max_retries:
+                    self.logger.info(f"等待 {self.retry_delay} 秒后重试...")
+                    time.sleep(self.retry_delay)
+                else:
+                    raise
+                    
+            except RequestException as e:
+                self.logger.error(f"请求异常: {e}")
+                if attempt < self.max_retries:
+                    self.logger.info(f"等待 {self.retry_delay} 秒后重试...")
+                    time.sleep(self.retry_delay)
+                else:
+                    raise
+        
+        raise Exception(f"请求失败，已达到最大重试次数: {self.max_retries + 1}")
+    
+    def search_reports(self, query: str, limit: Optional[int] = None, call_type: str = "normal") -> Dict[str, Any]:
+        """
+        搜索研究报告（原始响应，完全透明传递）
+        
+        Args:
+            query: 搜索关键词
+            limit: 结果数量限制（注意：此参数仅用于向后兼容，实际限制应由调用方处理）
+            call_type: 调用类型，normal或retry
+            
+        Returns:
+            完整的API响应数据（符合响应透明传递要求）
+            
+        Note:
+            根据问财OpenAPI网关规范条件六，此方法必须透明传递所有API响应，
+            包括错误响应，不做任何修改、过滤或重组。
+            调用方需要自己处理响应数据。这是推荐的使用方式。
+        """
+        try:
+            self.logger.info(f"搜索研究报告: {query}")
+            
+            payload = self._prepare_payload(query, limit)
+            
+            response_data = self._make_request_raw(payload, call_type)
+            
+            self.logger.info(f"API响应接收完成")
+            return response_data
+            
+        except Exception as e:
+            self.logger.error(f"搜索研究报告时发生错误: {e}")
+            raise
+    
+    def batch_search(self, queries: List[str], limit_per_query: Optional[int] = None, call_type: str = "normal") -> Dict[str, Dict[str, Any]]:
+        """
+        批量搜索研究报告（透明传递版本）
+        
+        Args:
+            queries: 搜索关键词列表
+            limit_per_query: 每个查询的结果数量限制（注意：此参数仅用于向后兼容）
+            call_type: 调用类型，normal或retry
+            
+        Returns:
+            字典，键为查询词，值为对应的透明传递的API响应
+            
+        Note:
+            此方法完全透明传递API响应，符合问财规范条件六。
+            调用方需要自己处理响应数据。
+        """
+        results = {}
+        
+        for i, query in enumerate(queries):
+            try:
+                self.logger.info(f"批量搜索 [{i+1}/{len(queries)}]: {query}")
+                response_data = self.search_reports(query, limit_per_query, call_type=call_type)
+                results[query] = response_data
+                
+                if i < len(queries) - 1:
+                    time.sleep(0.5)
+                    
+            except Exception as e:
+                self.logger.error(f"查询 '{query}' 搜索失败: {str(e)}")
+                results[query] = {"error": "search_failed", "message": str(e)}
+        
+        return results
+    
+    def test_connection(self) -> bool:
+        """
+        测试API连接
+        
+        Returns:
+            连接是否成功
+        """
+        try:
+            self.logger.info("测试API连接...")
+            
+            test_query = "测试"
+            test_payload = self._prepare_payload(test_query)
+            
+            response = self._make_request_raw(test_payload)
+            
+            if "error" not in response:
+                self.logger.info("API连接测试成功")
+                return True
+            else:
+                self.logger.warning(f"API连接测试失败: {response}")
+                return False
+                
+        except Exception as e:
+            self.logger.error(f"API连接测试异常: {e}")
+            return False
+
+
+if __name__ == "__main__":
+    import sys
+    
+    if not os.getenv("IWENCAI_API_KEY"):
+        print("请设置环境变量 IWENCAI_API_KEY")
+        sys.exit(1)
+    
+    try:
+        client = APIClient()
+        
+        if client.test_connection():
+            print("API连接测试成功")
+        else:
+            print("API连接测试失败")
+            sys.exit(1)
+            
+        test_queries = ["人工智能", "芯片行业"]
+        for query in test_queries:
+            print(f"\n搜索: {query}")
+            try:
+                response = client.search_reports(query, limit=3)
+                print(f"API响应类型: {type(response)}")
+                if isinstance(response, dict):
+                    print(f"响应键: {list(response.keys())}")
+            except Exception as e:
+                print(f"搜索失败: {e}")
+                
+    except Exception as e:
+        print(f"测试过程中发生错误: {e}")
+        sys.exit(1)

Skills/report-search/scripts/cli.py

@@ -0,0 +1,633 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+研报搜索技能命令行接口模块
+"""
+
+import argparse
+import sys
+import os
+import json
+import logging
+from typing import List, Optional, Dict, Any
+from pathlib import Path
+
+from api_client import APIClient, APIError
+from data_processor import DataProcessor
+from config import get_config
+
+
+class ResearchReportCLI:
+    """研报搜索命令行接口类"""
+    
+    def __init__(self):
+        """初始化CLI"""
+        self.config = get_config()
+        self.config.setup_logging()
+        self.logger = logging.getLogger(__name__)
+        
+        self.api_client = None
+        self.data_processor = None
+    
+    def initialize(self, config_file: Optional[str] = None) -> None:
+        """初始化组件"""
+        try:
+            self.api_client = APIClient(config_file)
+            self.data_processor = DataProcessor(config_file)
+            self.logger.info("CLI初始化完成")
+        except Exception as e:
+            self.logger.error(f"CLI初始化失败: {e}")
+            raise
+    
+    def parse_arguments(self) -> argparse.Namespace:
+        """解析命令行参数"""
+        parser = argparse.ArgumentParser(
+            description="研报搜索技能 - 搜索和分析财经研究报告",
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            epilog="""
+使用示例:
+  # 基本搜索
+  python research_report_search.py -q "人工智能行业研究报告"
+  
+  # 限制结果数量
+  python research_report_search.py -q "芯片行业" -l 5
+  
+  # 导出为CSV格式
+  python research_report_search.py -q "新能源汽车" -o results.csv -f csv
+  
+  # 批量处理
+  python research_report_search.py -i queries.txt -o ./results -f json
+  
+  # 时间范围搜索
+  python research_report_search.py -q "医药行业" --date-from "2024-01-01" --date-to "2024-03-31"
+  
+  # 获取帮助
+  python research_report_search.py -h
+            """
+        )
+        
+        # 基本搜索参数
+        parser.add_argument(
+            "-q", "--query",
+            help="搜索关键词（支持中文）",
+            type=str
+        )
+        
+        parser.add_argument(
+            "-o", "--output",
+            help="输出文件路径",
+            type=str
+        )
+        
+        parser.add_argument(
+            "-f", "--format",
+            help="输出格式（csv, json, text, markdown）",
+            choices=["csv", "json", "text", "markdown"],
+            default="text"
+        )
+        
+        parser.add_argument(
+            "-l", "--limit",
+            help="结果数量限制",
+            type=int,
+            default=10
+        )
+        
+        # 批量处理参数
+        parser.add_argument(
+            "-i", "--input",
+            help="输入文件路径（支持批量查询）",
+            type=str
+        )
+        
+        parser.add_argument(
+            "--input-format",
+            help="输入文件格式（txt, csv, json）",
+            choices=["txt", "csv", "json"],
+            default="txt"
+        )
+        
+        parser.add_argument(
+            "--output-dir",
+            help="输出目录（批量处理时使用）",
+            type=str
+        )
+        
+        # 过滤与排序参数
+        parser.add_argument(
+            "--date-from",
+            help="开始日期（YYYY-MM-DD）",
+            type=str
+        )
+        
+        parser.add_argument(
+            "--date-to",
+            help="结束日期（YYYY-MM-DD）",
+            type=str
+        )
+        
+        parser.add_argument(
+            "-d", "--days",
+            help="最近N天",
+            type=int
+        )
+        
+        parser.add_argument(
+            "--sort-by",
+            help="排序字段",
+            choices=["date", "relevance"],
+            default="date"
+        )
+        
+        parser.add_argument(
+            "--sort-order",
+            help="排序顺序",
+            choices=["asc", "desc"],
+            default="desc"
+        )
+        
+        # 其他参数
+        parser.add_argument(
+            "-v", "--verbose",
+            help="详细输出模式",
+            action="store_true"
+        )
+        
+        parser.add_argument(
+            "--debug",
+            help="调试模式",
+            action="store_true"
+        )
+        
+        parser.add_argument(
+            "--config",
+            help="配置文件路径",
+            type=str
+        )
+        
+        parser.add_argument(
+            "--test",
+            help="测试API连接",
+            action="store_true"
+        )
+        
+        return parser.parse_args()
+    
+    def load_queries_from_file(self, filepath: str, file_format: str = "txt") -> List[str]:
+        """从文件加载查询"""
+        try:
+            queries = []
+            
+            if file_format == "txt":
+                with open(filepath, 'r', encoding='utf-8') as f:
+                    for line in f:
+                        line = line.strip()
+                        if line and not line.startswith('#'):
+                            queries.append(line)
+            
+            elif file_format == "csv":
+                import pandas as pd
+                df = pd.read_csv(filepath)
+                if 'query' in df.columns:
+                    queries = df['query'].dropna().tolist()
+                else:
+                    # 使用第一列
+                    queries = df.iloc[:, 0].dropna().tolist()
+            
+            elif file_format == "json":
+                with open(filepath, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                    if isinstance(data, list):
+                        queries = [str(item) for item in data if item]
+                    elif isinstance(data, dict) and 'queries' in data:
+                        queries = [str(q) for q in data['queries'] if q]
+            
+            self.logger.info(f"从文件加载 {len(queries)} 个查询: {filepath}")
+            return queries
+            
+        except Exception as e:
+            self.logger.error(f"加载查询文件失败 {filepath}: {e}")
+            raise
+    
+    def process_single_query(self, args: argparse.Namespace) -> Dict[str, Any]:
+        """处理单个查询"""
+        result = {
+            "query": args.query,
+            "success": False,
+            "articles": [],
+            "error": None
+        }
+        
+        try:
+            # 搜索研究报告
+            self.logger.info(f"搜索研究报告: {args.query}")
+            response = self.api_client.search_reports(args.query, args.limit)
+            
+            # 检查是否为错误响应
+            if isinstance(response, dict) and "error" in response:
+                # 应用层可以选择性展示关键错误信息
+                error_type = response.get("error", "unknown")
+                status_code = response.get("status_code", 0)
+                raw_response = response.get("raw_response", "")
+                
+                # 对于常见错误（如401），只显示raw_response
+                if status_code == 401 and raw_response:
+                    print(f"\n{'=' * 60}")
+                    print(f"API错误 (状态码: {status_code}):")
+                    print(f"{'=' * 60}")
+                    print(raw_response)
+                    print(f"{'=' * 60}")
+                else:
+                    # 其他错误显示完整信息
+                    print(f"\n{'=' * 60}")
+                    print(f"API错误响应:")
+                    print(f"{'=' * 60}")
+                    print(json.dumps(response, indent=2, ensure_ascii=False))
+                    print(f"{'=' * 60}")
+                
+                result["error"] = response.get("error", "unknown_error")
+                result["status_code"] = status_code
+                return result
+            
+            # 从API响应中提取文章列表
+            articles = []
+            if isinstance(response, dict):
+                # 优先使用 data 字段，兼容 result 字段
+                if "data" in response:
+                    articles = response["data"]
+                    result["total"] = response.get("total", len(articles))
+                elif "result" in response:
+                    articles = response["result"]
+                    result["total"] = response.get("total", len(articles))
+            elif isinstance(response, list):
+                articles = response
+            
+            # 数据处理
+            if articles:
+                # 按日期过滤
+                if args.date_from or args.date_to:
+                    articles = self.data_processor.filter_by_date(
+                        articles, args.date_from, args.date_to
+                    )
+                
+                # 按最近N天过滤
+                if args.days:
+                    articles = self.data_processor.filter_by_days(articles, args.days)
+                
+                # 排序
+                articles = self.data_processor.sort_articles(
+                    articles, args.sort_by, args.sort_order
+                )
+                
+                # 提取关键信息
+                articles = self.data_processor.extract_key_info(articles)
+            
+            result["articles"] = articles
+            result["success"] = True
+            result["count"] = len(articles)
+            
+            self.logger.info(f"搜索完成: 找到 {len(articles)} 篇研究报告")
+            
+        except APIError as e:
+            result["error"] = str(e)
+            self.logger.error(f"API错误: {e}")
+        except Exception as e:
+            result["error"] = str(e)
+            self.logger.error(f"处理查询失败: {e}")
+        
+        return result
+    
+    def process_batch_queries(self, args: argparse.Namespace) -> Dict[str, Any]:
+        """处理批量查询"""
+        result = {
+            "success": False,
+            "queries": {},
+            "total_articles": 0,
+            "error": None
+        }
+        
+        try:
+            # 加载查询
+            queries = self.load_queries_from_file(args.input, args.input_format)
+            
+            if not queries:
+                result["error"] = "没有找到有效的查询"
+                return result
+            
+            # 批量搜索
+            self.logger.info(f"批量处理 {len(queries)} 个查询")
+            batch_results = self.api_client.batch_search(queries, args.limit)
+            
+            # 处理每个查询的结果
+            processed_results = {}
+            total_articles = 0
+            
+            for query, response in batch_results.items():
+                # 从API响应中提取文章列表
+                articles = []
+                if isinstance(response, dict):
+                    # 优先使用 data 字段，兼容 result 字段
+                    if "data" in response:
+                        articles = response["data"]
+                    elif "result" in response:
+                        articles = response["result"]
+                elif isinstance(response, list):
+                    articles = response
+                
+                if articles:
+                    # 数据处理
+                    if args.date_from or args.date_to:
+                        articles = self.data_processor.filter_by_date(
+                            articles, args.date_from, args.date_to
+                        )
+                    
+                    if args.days:
+                        articles = self.data_processor.filter_by_days(articles, args.days)
+                    
+                    articles = self.data_processor.sort_articles(
+                        articles, args.sort_by, args.sort_order
+                    )
+                    
+                    articles = self.data_processor.extract_key_info(articles)
+                
+                processed_results[query] = {
+                    "articles": articles,
+                    "count": len(articles)
+                }
+                total_articles += len(articles)
+            
+            result["queries"] = processed_results
+            result["total_articles"] = total_articles
+            result["success"] = True
+            
+            self.logger.info(f"批量处理完成: {len(queries)} 个查询, 共 {total_articles} 篇研究报告")
+            
+        except Exception as e:
+            result["error"] = str(e)
+            self.logger.error(f"批量处理失败: {e}")
+        
+        return result
+    
+    def save_results(self, result: Dict[str, Any], args: argparse.Namespace) -> None:
+        """保存结果"""
+        try:
+            if not result.get("success"):
+                self.logger.warning("结果不成功，跳过保存")
+                return
+            
+            output_format = args.format.lower()
+            
+            # 单个查询结果
+            if "query" in result:
+                articles = result.get("articles", [])
+                
+                if not articles:
+                    self.logger.warning("没有研究报告可保存")
+                    return
+                
+                if args.output:
+                    output_path = args.output
+                    
+                    if output_format == "csv":
+                        self.data_processor.save_to_csv(articles, output_path)
+                    elif output_format == "json":
+                        self.data_processor.save_to_json(articles, output_path)
+                    elif output_format == "markdown":
+                        self.data_processor.save_to_markdown(articles, output_path)
+                    elif output_format == "text":
+                        self._save_to_text(articles, output_path)
+                    else:
+                        self.logger.error(f"不支持的输出格式: {output_format}")
+                
+                else:
+                    # 输出到控制台
+                    self._print_to_console(articles, output_format)
+            
+            # 批量查询结果
+            elif "queries" in result:
+                if args.output_dir:
+                    output_dir = Path(args.output_dir)
+                    output_dir.mkdir(parents=True, exist_ok=True)
+                    
+                    for query, query_result in result["queries"].items():
+                        articles = query_result.get("articles", [])
+                        
+                        if articles:
+                            # 创建安全的文件名
+                            safe_query = "".join(c if c.isalnum() else "_" for c in query)
+                            if len(safe_query) > 50:
+                                safe_query = safe_query[:50]
+                            
+                            if output_format == "csv":
+                                output_path = output_dir / f"{safe_query}.csv"
+                                self.data_processor.save_to_csv(articles, str(output_path))
+                            elif output_format == "json":
+                                output_path = output_dir / f"{safe_query}.json"
+                                self.data_processor.save_to_json(articles, str(output_path))
+                            elif output_format == "markdown":
+                                output_path = output_dir / f"{safe_query}.md"
+                                self.data_processor.save_to_markdown(articles, str(output_path))
+                            elif output_format == "text":
+                                output_path = output_dir / f"{safe_query}.txt"
+                                self._save_to_text(articles, str(output_path))
+                    
+                    # 保存汇总文件
+                    summary_path = output_dir / f"summary.{output_format}"
+                    if output_format == "json":
+                        with open(summary_path, 'w', encoding='utf-8') as f:
+                            json.dump(result, f, ensure_ascii=False, indent=2)
+                    
+                    self.logger.info(f"批量结果保存到目录: {output_dir}")
+                
+                else:
+                    # 输出汇总信息到控制台
+                    self._print_batch_summary(result)
+            
+        except Exception as e:
+            self.logger.error(f"保存结果失败: {e}")
+            raise
+    
+    def _save_to_text(self, articles: List[Dict[str, Any]], filepath: str) -> None:
+        """保存到文本文件"""
+        with open(filepath, 'w', encoding='utf-8') as f:
+            f.write(f"研究报告搜索结果\n")
+            f.write(f"搜索时间: {self._get_current_time()}\n")
+            f.write(f"报告数量: {len(articles)} 篇\n")
+            f.write("=" * 80 + "\n\n")
+            
+            for i, article in enumerate(articles, 1):
+                f.write(f"{i}. {article.get('title', '无标题')}\n")
+                f.write(f"   发布时间: {article.get('publish_date', '未知')}\n")
+                f.write(f"   原文链接: {article.get('url', '')}\n")
+                
+                summary = article.get("summary", "")
+                if summary:
+                    f.write(f"   摘要: {summary[:200]}...\n")
+                
+                # 提取的信息
+                if "extracted_info" in article:
+                    extracted = article["extracted_info"]
+                    info_parts = []
+                    
+                    if extracted.get("rating"):
+                        info_parts.append(f"评级: {extracted['rating']}")
+                    if extracted.get("target_price"):
+                        info_parts.append(f"目标价: {extracted['target_price']}元")
+                    if extracted.get("industry"):
+                        info_parts.append(f"行业: {extracted['industry']}")
+                    
+                    if info_parts:
+                        f.write(f"   提取信息: {', '.join(info_parts)}\n")
+                
+                f.write("\n")
+        
+        self.logger.info(f"保存到文本文件: {len(articles)} 篇研究报告 -> {filepath}")
+    
+    def _print_to_console(self, articles: List[Dict[str, Any]], output_format: str) -> None:
+        """输出到控制台"""
+        if output_format == "text":
+            print(f"\n研究报告搜索结果")
+            print(f"搜索时间: {self._get_current_time()}")
+            print(f"报告数量: {len(articles)} 篇")
+            print("=" * 80)
+            
+            for i, article in enumerate(articles, 1):
+                print(f"\n{i}. {article.get('title', '无标题')}")
+                print(f"   发布时间: {article.get('publish_date', '未知')}")
+                print(f"   原文链接: {article.get('url', '')}")
+                
+                summary = article.get("summary", "")
+                if summary:
+                    print(f"   摘要: {summary[:150]}...")
+                
+                # 提取的信息
+                if "extracted_info" in article:
+                    extracted = article["extracted_info"]
+                    info_parts = []
+                    
+                    if extracted.get("rating"):
+                        info_parts.append(f"评级: {extracted['rating']}")
+                    if extracted.get("target_price"):
+                        info_parts.append(f"目标价: {extracted['target_price']}元")
+                    if extracted.get("industry"):
+                        info_parts.append(f"行业: {extracted['industry']}")
+                    
+                    if info_parts:
+                        print(f"   提取信息: {', '.join(info_parts)}")
+            
+            print("\n" + "=" * 80)
+            
+        elif output_format == "json":
+            print(json.dumps(articles, ensure_ascii=False, indent=2))
+        
+        else:
+            # 默��简单输出
+            for i, article in enumerate(articles, 1):
+                print(f"{i}. {article.get('title', '无标题')}")
+                if i >= 10:  # 只显示前10条
+                    print(f"... 还有 {len(articles) - 10} 条结果")
+                    break
+    
+    def _print_batch_summary(self, result: Dict[str, Any]) -> None:
+        """输出批量处理摘要"""
+        print(f"\n批量处理结果摘要")
+        print(f"处理时间: {self._get_current_time()}")
+        print(f"查询数量: {len(result.get('queries', {}))}")
+        print(f"总报告数量: {result.get('total_articles', 0)}")
+        print("=" * 80)
+        
+        for query, query_result in result.get("queries", {}).items():
+            count = query_result.get("count", 0)
+            print(f"  {query}: {count} 篇")
+        
+        print("=" * 80)
+    
+    def _get_current_time(self) -> str:
+        """获取当前时间字符串"""
+        from datetime import datetime
+        return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    
+    def test_connection(self) -> bool:
+        """测试API连接"""
+        try:
+            self.logger.info("测试API连接...")
+            success = self.api_client.test_connection()
+            
+            if success:
+                print("API连接测试成功")
+                self.logger.info("API连接测试成功")
+            else:
+                print("API连接测试失败")
+                self.logger.warning("API连接测试失败")
+            
+            return success
+            
+        except Exception as e:
+            print(f"API连接测试失败: {e}")
+            self.logger.error(f"API连接测试失败: {e}")
+            return False
+    
+    def run(self) -> int:
+        """运行CLI"""
+        try:
+            # 解析参数
+            args = self.parse_arguments()
+            
+            # 设置日志级别
+            if args.debug:
+                logging.getLogger().setLevel(logging.DEBUG)
+            elif args.verbose:
+                logging.getLogger().setLevel(logging.INFO)
+            
+            # 初始化
+            self.initialize(args.config)
+            
+            # 测试模式
+            if args.test:
+                return 0 if self.test_connection() else 1
+            
+            # 检查必要的参数
+            if not args.query and not args.input:
+                print("错误: 必须指定查询参数 (-q/--query) 或输入文件 (-i/--input)")
+                return 1
+            
+            # 处理查询
+            if args.input:
+                # 批量处理
+                result = self.process_batch_queries(args)
+            else:
+                # 单个查询
+                result = self.process_single_query(args)
+            
+            # 保存结果
+            if result.get("success"):
+                self.save_results(result, args)
+                
+                # 显示成功消息
+                if args.input:
+                    print(f"\n批量处理完成: {result.get('total_articles', 0)} 篇研究报告")
+                else:
+                    print(f"\n搜索完成: {result.get('count', 0)} 篇研究报告")
+                
+                return 0
+            else:
+                print(f"\n处理失败: {result.get('error', '未知错误')}")
+                return 1
+            
+        except KeyboardInterrupt:
+            print("\n用户中断")
+            return 130
+        except Exception as e:
+            self.logger.error(f"CLI运行失败: {e}")
+            print(f"错误: {e}")
+            return 1
+
+
+def main():
+    """主函数"""
+    cli = ResearchReportCLI()
+    return cli.run()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

Skills/report-search/scripts/config.example.json

@@ -0,0 +1,26 @@
+{
+  "api": {
+    "base_url": "https://openapi.iwencai.com",
+    "endpoint": "/v1/comprehensive/search",
+    "timeout": 30,
+    "max_retries": 3,
+    "retry_delay": 1.0
+  },
+  "search": {
+    "channels": ["report"],
+    "app_id": "AIME_SKILL",
+    "default_limit": 10,
+    "default_days": 30,
+    "min_articles_for_sufficient": 3
+  },
+  "output": {
+    "default_format": "text",
+    "csv_encoding": "utf-8-sig",
+    "json_indent": 2
+  },
+  "logging": {
+    "level": "INFO",
+    "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+  },
+  "注意": "API密钥应从环境变量 IWENCAI_API_KEY 获取，不要在此配置文件中硬编码"
+}

Skills/report-search/scripts/config.py

@@ -0,0 +1,206 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+研报搜索技能配置管理模块
+"""
+
+import os
+import json
+import logging
+from typing import Dict, Any, Optional
+
+# 默认配置
+DEFAULT_CONFIG = {
+    "api": {
+        "base_url": "https://openapi.iwencai.com",
+        "endpoint": "/v1/comprehensive/search",
+        "timeout": 30,
+        "max_retries": 3,
+        "retry_delay": 1.0
+    },
+    "search": {
+        "channels": ["report"],
+        "app_id": "AIME_SKILL",
+        "default_limit": 10,
+        "default_days": 30,
+        "min_articles_for_sufficient": 3
+    },
+    "output": {
+        "default_format": "text",
+        "csv_encoding": "utf-8-sig",
+        "json_indent": 2
+    },
+    "logging": {
+        "level": "INFO",
+        "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    }
+}
+
+
+class Config:
+    """配置管理类"""
+    
+    def __init__(self, config_file: Optional[str] = None):
+        """
+        初始化配置
+        
+        Args:
+            config_file: 配置文件路径，如果为None则使用默认配置
+        """
+        self.config = DEFAULT_CONFIG.copy()
+        
+        # 从配置文件加载配置（如果提供）
+        if config_file and os.path.exists(config_file):
+            self.load_from_file(config_file)
+        
+        # 从环境变量覆盖配置
+        self.load_from_env()
+        
+        # 验证配置
+        self.validate()
+    
+    def load_from_file(self, config_file: str) -> None:
+        """从配置文件加载配置"""
+        try:
+            with open(config_file, 'r', encoding='utf-8') as f:
+                file_config = json.load(f)
+                self._merge_config(file_config)
+            logging.info(f"从文件加载配置: {config_file}")
+        except (json.JSONDecodeError, IOError) as e:
+            logging.warning(f"加载配置文件失败 {config_file}: {e}, 使用默认配置")
+    
+    def load_from_env(self) -> None:
+        """从环境变量加载配置"""
+        # API配置
+        api_key = os.getenv("IWENCAI_API_KEY")
+        if api_key:
+            # API Key存储在环境变量中，不在配置中硬编码
+            logging.info("从环境变量加载API Key")
+        
+        # 超时时间
+        timeout = os.getenv("API_TIMEOUT")
+        if timeout:
+            try:
+                self.config["api"]["timeout"] = int(timeout)
+            except ValueError:
+                pass
+        
+        # 日志级别
+        log_level = os.getenv("LOG_LEVEL")
+        if log_level:
+            self.config["logging"]["level"] = log_level.upper()
+    
+    def _merge_config(self, new_config: Dict[str, Any]) -> None:
+        """合并配置"""
+        for key, value in new_config.items():
+            if key in self.config and isinstance(self.config[key], dict) and isinstance(value, dict):
+                # 递归合并字典
+                self.config[key].update(value)
+            else:
+                # 直接覆盖
+                self.config[key] = value
+    
+    def validate(self) -> None:
+        """验证配置"""
+        # 检查必要的API配置
+        if not self.config["api"]["base_url"]:
+            raise ValueError("API base_url 不能为空")
+        
+        if not self.config["api"]["endpoint"]:
+            raise ValueError("API endpoint 不能为空")
+        
+        # 检查搜索配置
+        if not self.config["search"]["channels"]:
+            raise ValueError("搜索渠道 channels 不能为空")
+        
+        if not self.config["search"]["app_id"]:
+            raise ValueError("应用ID app_id 不能为空")
+        
+        # 检查超时时间
+        if self.config["api"]["timeout"] <= 0:
+            raise ValueError("API timeout 必须大于0")
+        
+        # 检查重试次数
+        if self.config["api"]["max_retries"] < 0:
+            raise ValueError("API max_retries 不能为负数")
+    
+    def get(self, key: str, default: Any = None) -> Any:
+        """获取配置值"""
+        keys = key.split('.')
+        value = self.config
+        
+        for k in keys:
+            if isinstance(value, dict) and k in value:
+                value = value[k]
+            else:
+                return default
+        
+        return value
+    
+    def set(self, key: str, value: Any) -> None:
+        """设置配置值"""
+        keys = key.split('.')
+        config = self.config
+        
+        for i, k in enumerate(keys[:-1]):
+            if k not in config:
+                config[k] = {}
+            config = config[k]
+        
+        config[keys[-1]] = value
+    
+    def get_api_key(self) -> str:
+        """获取API Key（从环境变量）"""
+        api_key = os.getenv("IWENCAI_API_KEY")
+        if not api_key:
+            raise ValueError("请设置环境变量 IWENCAI_API_KEY")
+        return api_key
+    
+    def get_api_url(self) -> str:
+        """获取完整的API URL"""
+        base_url = self.config["api"]["base_url"].rstrip('/')
+        endpoint = self.config["api"]["endpoint"].lstrip('/')
+        return f"{base_url}/{endpoint}"
+    
+    def setup_logging(self) -> None:
+        """设置日志"""
+        log_level = self.config["logging"]["level"]
+        log_format = self.config["logging"]["format"]
+        
+        # 设置日志级别
+        numeric_level = getattr(logging, log_level.upper(), None)
+        if not isinstance(numeric_level, int):
+            numeric_level = logging.INFO
+        
+        logging.basicConfig(
+            level=numeric_level,
+            format=log_format,
+            datefmt="%Y-%m-%d %H:%M:%S"
+        )
+
+
+# 全局配置实例
+_config_instance: Optional[Config] = None
+
+
+def get_config(config_file: Optional[str] = None) -> Config:
+    """获取全局配置实例"""
+    global _config_instance
+    if _config_instance is None:
+        _config_instance = Config(config_file)
+    return _config_instance
+
+
+if __name__ == "__main__":
+    # 测试配置模块
+    config = get_config()
+    print("API URL:", config.get_api_url())
+    print("搜索渠道:", config.get("search.channels"))
+    print("默认限制:", config.get("search.default_limit"))
+    
+    # 测试环境变量
+    try:
+        api_key = config.get_api_key()
+        print("API Key:", "已设置" if api_key else "未设置")
+    except ValueError as e:
+        print(f"API Key错误: {e}")

Skills/report-search/scripts/data_processor.py

@@ -0,0 +1,600 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+研报搜索技能数据处理模块
+"""
+
+import json
+import csv
+import logging
+from typing import Dict, List, Any, Optional, Tuple
+from datetime import datetime, timedelta
+import pandas as pd
+import numpy as np
+
+from config import get_config
+
+
+class DataProcessor:
+    """数据处理类"""
+    
+    def __init__(self, config_file: Optional[str] = None):
+        """
+        初始化数据处理类
+        
+        Args:
+            config_file: 配置文件路径
+        """
+        self.config = get_config(config_file)
+        
+        # 设置日志
+        self.config.setup_logging()
+        self.logger = logging.getLogger(__name__)
+        
+        # 初始化关键词提取器（简单版本）
+        self._init_keyword_extractor()
+    
+    def _init_keyword_extractor(self) -> None:
+        """初始化关键词提取器（简单实现）"""
+        # 行业关键词
+        self.industry_keywords = [
+            "人工智能", "芯片", "半导体", "新能源", "电动汽车", "医药", "医疗", "金融",
+            "银行", "保险", "证券", "消费", "零售", "制造", "工业", "科技", "互联网",
+            "软件", "硬件", "通信", "5G", "物联网", "云计算", "大数据", "区块链"
+        ]
+        
+        # 报告类型关键词
+        self.report_type_keywords = [
+            "研究报告", "分析报告", "行业报告", "深度报告", "投资报告", "市场报告",
+            "趋势报告", "前景分析", "投资建议", "评级报告", "目标价"
+        ]
+    
+    def filter_by_date(self, articles: List[Dict[str, Any]], 
+                      date_from: Optional[str] = None,
+                      date_to: Optional[str] = None) -> List[Dict[str, Any]]:
+        """
+        按日期过滤研究报告
+        
+        Args:
+            articles: 研究报告列表
+            date_from: 开始日期 (YYYY-MM-DD)
+            date_to: 结束日期 (YYYY-MM-DD)
+            
+        Returns:
+            过滤后的研究报告列表
+        """
+        if not articles:
+            return []
+        
+        filtered_articles = []
+        
+        try:
+            # 解析日期范围
+            from_date = None
+            to_date = None
+            
+            if date_from:
+                from_date = datetime.strptime(date_from, "%Y-%m-%d")
+            
+            if date_to:
+                to_date = datetime.strptime(date_to, "%Y-%m-%d")
+            
+            # 过滤文章
+            for article in articles:
+                publish_date_str = article.get("publish_date", "")
+                
+                if not publish_date_str:
+                    # 如果没有发布日期，默认保留
+                    filtered_articles.append(article)
+                    continue
+                
+                try:
+                    # 尝试解析发布日期
+                    # 格式可能是 "YYYY-MM-DD HH:MM:SS" 或 "YYYY-MM-DD"
+                    if " " in publish_date_str:
+                        publish_date = datetime.strptime(publish_date_str, "%Y-%m-%d %H:%M:%S")
+                    else:
+                        publish_date = datetime.strptime(publish_date_str, "%Y-%m-%d")
+                    
+                    # 检查是否在日期范围内
+                    if from_date and publish_date < from_date:
+                        continue
+                    
+                    if to_date and publish_date > to_date:
+                        continue
+                    
+                    filtered_articles.append(article)
+                    
+                except ValueError:
+                    # 日期格式解析失败，保留文章
+                    filtered_articles.append(article)
+            
+            self.logger.info(f"按日期过滤: 从 {len(articles)} 篇过滤到 {len(filtered_articles)} 篇")
+            
+        except Exception as e:
+            self.logger.error(f"按日期过滤失败: {e}")
+            # 出错时返回原始数据
+            return articles
+        
+        return filtered_articles
+    
+    def filter_by_days(self, articles: List[Dict[str, Any]], days: int) -> List[Dict[str, Any]]:
+        """
+        按最近N天过滤研究报告
+        
+        Args:
+            articles: 研究报告列表
+            days: 最近N天
+            
+        Returns:
+            过滤后的研究报告列表
+        """
+        if not articles or days <= 0:
+            return articles
+        
+        try:
+            # 计算截止日期
+            cutoff_date = datetime.now() - timedelta(days=days)
+            
+            filtered_articles = []
+            for article in articles:
+                publish_date_str = article.get("publish_date", "")
+                
+                if not publish_date_str:
+                    # 如果没有发布日期，默认保留
+                    filtered_articles.append(article)
+                    continue
+                
+                try:
+                    # 尝试解析发布日期
+                    if " " in publish_date_str:
+                        publish_date = datetime.strptime(publish_date_str, "%Y-%m-%d %H:%M:%S")
+                    else:
+                        publish_date = datetime.strptime(publish_date_str, "%Y-%m-%d")
+                    
+                    # 检查是否在最近N天内
+                    if publish_date >= cutoff_date:
+                        filtered_articles.append(article)
+                        
+                except ValueError:
+                    # 日期格式解析失败，保留文章
+                    filtered_articles.append(article)
+            
+            self.logger.info(f"按最近 {days} 天过滤: 从 {len(articles)} 篇过滤到 {len(filtered_articles)} 篇")
+            
+            return filtered_articles
+            
+        except Exception as e:
+            self.logger.error(f"按天数过滤失败: {e}")
+            return articles
+    
+    def sort_articles(self, articles: List[Dict[str, Any]], 
+                     sort_by: str = "date",
+                     sort_order: str = "desc") -> List[Dict[str, Any]]:
+        """
+        排序研究报告
+        
+        Args:
+            articles: 研究报告列表
+            sort_by: 排序字段 (date, relevance)
+            sort_order: 排序顺序 (asc, desc)
+            
+        Returns:
+            排序后的研究报告列表
+        """
+        if not articles:
+            return []
+        
+        try:
+            # 创建可排序的副本
+            sorted_articles = articles.copy()
+            
+            if sort_by == "date":
+                # 按日期排序
+                def get_date(article):
+                    publish_date_str = article.get("publish_date", "")
+                    if not publish_date_str:
+                        return datetime.min
+                    
+                    try:
+                        if " " in publish_date_str:
+                            return datetime.strptime(publish_date_str, "%Y-%m-%d %H:%M:%S")
+                        else:
+                            return datetime.strptime(publish_date_str, "%Y-%m-%d")
+                    except ValueError:
+                        return datetime.min
+                
+                sorted_articles.sort(key=get_date, reverse=(sort_order == "desc"))
+                
+            elif sort_by == "relevance":
+                # 按相关性排序（简单实现：按标题长度和关键词匹配）
+                def get_relevance_score(article):
+                    title = article.get("title", "").lower()
+                    summary = article.get("summary", "").lower()
+                    
+                    score = 0
+                    
+                    # 标题长度（适中为好）
+                    title_len = len(title)
+                    if 10 <= title_len <= 50:
+                        score += 1
+                    
+                    # 包含关键词
+                    for keyword in self.industry_keywords + self.report_type_keywords:
+                        if keyword in title or keyword in summary:
+                            score += 2
+                    
+                    # 包含数字（可能表示目标价或日期）
+                    if any(char.isdigit() for char in title):
+                        score += 1
+                    
+                    return score
+                
+                sorted_articles.sort(key=get_relevance_score, reverse=(sort_order == "desc"))
+            
+            self.logger.info(f"按 {sort_by} 排序 ({sort_order}): 排序 {len(sorted_articles)} 篇研究报告")
+            
+            return sorted_articles
+            
+        except Exception as e:
+            self.logger.error(f"排序失败: {e}")
+            return articles
+    
+    def extract_key_info(self, articles: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """
+        提取关键信息
+        
+        Args:
+            articles: 研究报告列表
+            
+        Returns:
+            包含提取信息的研究报告列表
+        """
+        if not articles:
+            return []
+        
+        processed_articles = []
+        
+        for article in articles:
+            processed_article = article.copy()
+            
+            # 提取标题中的关键信息
+            title = article.get("title", "")
+            summary = article.get("summary", "")
+            
+            # 提取投资评级
+            rating_keywords = ["买入", "增持", "持有", "减持", "卖出", "推荐", "谨慎推荐"]
+            rating = None
+            for keyword in rating_keywords:
+                if keyword in title or keyword in summary:
+                    rating = keyword
+                    break
+            
+            # 提取目标价
+            target_price = None
+            import re
+            price_patterns = [
+                r"目标价\s*[:：]?\s*(\d+(?:\.\d+)?)\s*元",
+                r"(\d+(?:\.\d+)?)\s*元\s*目标价",
+                r"目标价\s*(\d+(?:\.\d+)?)"
+            ]
+            
+            for pattern in price_patterns:
+                match = re.search(pattern, title + " " + summary)
+                if match:
+                    target_price = match.group(1)
+                    break
+            
+            # 提取行业
+            industry = None
+            for keyword in self.industry_keywords:
+                if keyword in title or keyword in summary:
+                    industry = keyword
+                    break
+            
+            # 添加提取的信息
+            processed_article["extracted_info"] = {
+                "rating": rating,
+                "target_price": target_price,
+                "industry": industry,
+                "has_analysis": any(keyword in summary for keyword in ["分析", "逻辑", "原因", "因素"])
+            }
+            
+            processed_articles.append(processed_article)
+        
+        self.logger.info(f"提取关键信息: 处理 {len(processed_articles)} 篇研究报告")
+        
+        return processed_articles
+    
+    def save_to_csv(self, articles: List[Dict[str, Any]], filepath: str) -> None:
+        """
+        保存研究报告到CSV文件
+        
+        Args:
+            articles: 研究报告列表
+            filepath: 输出文件路径
+        """
+        if not articles:
+            self.logger.warning("没有研究报告可保存")
+            return
+        
+        try:
+            # 准备CSV数据
+            csv_data = []
+            for article in articles:
+                row = {
+                    "title": article.get("title", ""),
+                    "summary": article.get("summary", ""),
+                    "url": article.get("url", ""),
+                    "publish_date": article.get("publish_date", "")
+                }
+                
+                # 添加提取的信息
+                if "extracted_info" in article:
+                    extracted = article["extracted_info"]
+                    row["rating"] = extracted.get("rating", "")
+                    row["target_price"] = extracted.get("target_price", "")
+                    row["industry"] = extracted.get("industry", "")
+                    row["has_analysis"] = extracted.get("has_analysis", False)
+                
+                csv_data.append(row)
+            
+            # 保存到CSV
+            df = pd.DataFrame(csv_data)
+            df.to_csv(filepath, index=False, encoding='utf-8-sig')
+            
+            self.logger.info(f"保存到CSV: {len(articles)} 篇研究报告 -> {filepath}")
+            
+        except Exception as e:
+            self.logger.error(f"保存到CSV失败: {e}")
+            raise
+    
+    def save_to_json(self, articles: List[Dict[str, Any]], filepath: str) -> None:
+        """
+        保存研究报告到JSON文件
+        
+        Args:
+            articles: 研究报告列表
+            filepath: 输出文件路径
+        """
+        if not articles:
+            self.logger.warning("没有研究报告可保存")
+            return
+        
+        try:
+            with open(filepath, 'w', encoding='utf-8') as f:
+                json.dump(articles, f, ensure_ascii=False, indent=2)
+            
+            self.logger.info(f"保存到JSON: {len(articles)} 篇研究报告 -> {filepath}")
+            
+        except Exception as e:
+            self.logger.error(f"保存到JSON失败: {e}")
+            raise
+    
+    def save_to_markdown(self, articles: List[Dict[str, Any]], filepath: str) -> None:
+        """
+        保存研究报告到Markdown文件
+        
+        Args:
+            articles: 研究报告列表
+            filepath: 输出文件路径
+        """
+        if not articles:
+            self.logger.warning("没有研究报告可保存")
+            return
+        
+        try:
+            with open(filepath, 'w', encoding='utf-8') as f:
+                f.write("# 研究报告汇总\n\n")
+                f.write(f"**生成时间**: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
+                f.write(f"**报告数量**: {len(articles)} 篇\n\n")
+                
+                for i, article in enumerate(articles, 1):
+                    f.write(f"## {i}. {article.get('title', '无标题')}\n\n")
+                    
+                    # 基本信息
+                    f.write(f"**发布时间**: {article.get('publish_date', '未知')}\n\n")
+                    f.write(f"**原文链接**: [{article.get('url', '')}]({article.get('url', '')})\n\n")
+                    
+                    # 摘要
+                    summary = article.get("summary", "")
+                    if summary:
+                        f.write(f"**摘要**: {summary}\n\n")
+                    
+                    # 提取的信息
+                    if "extracted_info" in article:
+                        extracted = article["extracted_info"]
+                        
+                        info_lines = []
+                        if extracted.get("rating"):
+                            info_lines.append(f"- **投资评级**: {extracted['rating']}")
+                        if extracted.get("target_price"):
+                            info_lines.append(f"- **目标价**: {extracted['target_price']}元")
+                        if extracted.get("industry"):
+                            info_lines.append(f"- **所属行业**: {extracted['industry']}")
+                        if extracted.get("has_analysis"):
+                            info_lines.append(f"- **包含分析**: 是")
+                        
+                        if info_lines:
+                            f.write("**提取信息**:\n")
+                            for line in info_lines:
+                                f.write(f"{line}\n")
+                            f.write("\n")
+                    
+                    f.write("---\n\n")
+            
+            self.logger.info(f"保存到Markdown: {len(articles)} 篇研究报告 -> {filepath}")
+            
+        except Exception as e:
+            self.logger.error(f"保存到Markdown失败: {e}")
+            raise
+    
+    def analyze_articles(self, articles: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """
+        分析研究报告
+        
+        Args:
+            articles: 研究报告列表
+            
+        Returns:
+            分析结果
+        """
+        if not articles:
+            return {"error": "没有研究报告可分析"}
+        
+        try:
+            analysis = {
+                "total_count": len(articles),
+                "date_range": None,
+                "industry_distribution": {},
+                "rating_distribution": {},
+                "avg_summary_length": 0,
+                "analysis_coverage": 0
+            }
+            
+            # 分析日期范围
+            dates = []
+            for article in articles:
+                publish_date_str = article.get("publish_date", "")
+                if publish_date_str:
+                    try:
+                        if " " in publish_date_str:
+                            date = datetime.strptime(publish_date_str, "%Y-%m-%d %H:%M:%S")
+                        else:
+                            date = datetime.strptime(publish_date_str, "%Y-%m-%d")
+                        dates.append(date)
+                    except ValueError:
+                        pass
+            
+            if dates:
+                min_date = min(dates)
+                max_date = max(dates)
+                analysis["date_range"] = {
+                    "start": min_date.strftime("%Y-%m-%d"),
+                    "end": max_date.strftime("%Y-%m-%d"),
+                    "days": (max_date - min_date).days
+                }
+            
+            # 分析行业分布
+            for article in articles:
+                if "extracted_info" in article:
+                    industry = article["extracted_info"].get("industry")
+                    if industry:
+                        analysis["industry_distribution"][industry] = \
+                            analysis["industry_distribution"].get(industry, 0) + 1
+            
+            # 分析评级分布
+            for article in articles:
+                if "extracted_info" in article:
+                    rating = article["extracted_info"].get("rating")
+                    if rating:
+                        analysis["rating_distribution"][rating] = \
+                            analysis["rating_distribution"].get(rating, 0) + 1
+            
+            # 分析摘要长度
+            summary_lengths = []
+            for article in articles:
+                summary = article.get("summary", "")
+                if summary:
+                    summary_lengths.append(len(summary))
+            
+            if summary_lengths:
+                analysis["avg_summary_length"] = sum(summary_lengths) / len(summary_lengths)
+            
+            # 分析分析覆盖率
+            articles_with_analysis = 0
+            for article in articles:
+                if "extracted_info" in article:
+                    if article["extracted_info"].get("has_analysis"):
+                        articles_with_analysis += 1
+            
+            if articles:
+                analysis["analysis_coverage"] = articles_with_analysis / len(articles)
+            
+            self.logger.info(f"分析研究报告: {len(articles)} 篇")
+            
+            return analysis
+            
+        except Exception as e:
+            self.logger.error(f"分析研究报告失败: {e}")
+            return {"error": f"分析失败: {str(e)}"}
+
+
+if __name__ == "__main__":
+    # 测试数据处理模块
+    import sys
+    
+    # 测试数据
+    test_articles = [
+        {
+            "title": "人工智能行业研究报告：买入评级，目标价120元",
+            "summary": "本报告分析了人工智能行业的发展趋势，包括技术突破、应用场景、市场规模等方面的内容。",
+            "url": "https://example.com/reports/ai-2024",
+            "publish_date": "2024-01-15 09:30:00"
+        },
+        {
+            "title": "芯片行业分析报告：增持评级",
+            "summary": "报告详细介绍了芯片行业的最新发展动态和投资机会。",
+            "url": "https://example.com/reports/chip-2024",
+            "publish_date": "2024-01-14 14:20:00"
+        },
+        {
+            "title": "新能源汽车行业报告",
+            "summary": "分析新能源汽车行业的发展前景和投资建议。",
+            "url": "https://example.com/reports/ev-2024",
+            "publish_date": "2024-01-13 11:15:00"
+        }
+    ]
+    
+    try:
+        processor = DataProcessor()
+        
+        # 测试过滤
+        print("测试按日期过滤...")
+        filtered = processor.filter_by_date(test_articles, date_from="2024-01-14")
+        print(f"过滤后: {len(filtered)} 篇")
+        
+        # 测试排序
+        print("\n测试排序...")
+        sorted_articles = processor.sort_articles(test_articles, sort_by="date", sort_order="desc")
+        print(f"排序后第一篇标题: {sorted_articles[0].get('title')}")
+        
+        # 测试提取关键信息
+        print("\n测试提取关键信息...")
+        processed = processor.extract_key_info(test_articles)
+        for article in processed:
+            print(f"标题: {article.get('title')}")
+            print(f"评级: {article.get('extracted_info', {}).get('rating')}")
+            print(f"目标价: {article.get('extracted_info', {}).get('target_price')}")
+            print()
+        
+        # 测试分析
+        print("\n测试分析...")
+        analysis = processor.analyze_articles(processed)
+        print(f"总数量: {analysis.get('total_count')}")
+        print(f"行业分布: {analysis.get('industry_distribution')}")
+        print(f"评级分布: {analysis.get('rating_distribution')}")
+        
+        # 测试保存
+        print("\n测试保存...")
+        import tempfile
+        import os
+        
+        with tempfile.TemporaryDirectory() as tmpdir:
+            csv_path = os.path.join(tmpdir, "test.csv")
+            json_path = os.path.join(tmpdir, "test.json")
+            md_path = os.path.join(tmpdir, "test.md")
+            
+            processor.save_to_csv(processed, csv_path)
+            processor.save_to_json(processed, json_path)
+            processor.save_to_markdown(processed, md_path)
+            
+            print(f"CSV文件大小: {os.path.getsize(csv_path)} 字节")
+            print(f"JSON文件大小: {os.path.getsize(json_path)} 字节")
+            print(f"Markdown文件大小: {os.path.getsize(md_path)} 字节")
+            
+            print("\n测试完成!")
+            
+    except Exception as e:
+        print(f"测试失败: {e}")
+        sys.exit(1)

Skills/report-search/scripts/example_usage.py

@@ -0,0 +1,343 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+研报搜索技能使用示例
+符合iwencai-skill-creator规范
+"""
+
+import os
+import sys
+import json
+from pathlib import Path
+
+# 添加当前目录到Python路径
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from api_client import APIClient, APIError
+from data_processor import DataProcessor
+
+
+def example_basic_search():
+    """示例1: 基本搜索（响应透明传递示例）"""
+    print("=" * 80)
+    print("示例1: 基本搜索（响应透明传递示例）")
+    print("=" * 80)
+    
+    try:
+        # 初始化API客户端
+        client = APIClient()
+        
+        # 搜索研究报告（注意：现在返回完整的API响应）
+        query = "人工智能行业研究报告"
+        response_data = client.search_reports(query)
+        
+        print(f"搜索关键词: {query}")
+        print(f"完整API响应结构: {list(response_data.keys())}")
+        
+        # 从响应中提取数据（调用方决定如何处理）
+        articles = response_data.get("data", [])
+        print(f"找到 {len(articles)} 篇研究报告:")
+        
+        for i, article in enumerate(articles[:5], 1):  # 只显示前5篇
+            print(f"\n{i}. {article.get('title', '无标题')}")
+            print(f"   摘要: {article.get('summary', '无摘要')[:100]}...")
+            print(f"   发布时间: {article.get('publish_date', '未知')}")
+            print(f"   原文链接: {article.get('url', '')}")
+        
+        # 显示响应元数据（透明传递的一部分）
+        if "metadata" in response_data:
+            print(f"\n响应元数据: {response_data.get('metadata', {})}")
+        
+        print("\n" + "=" * 80)
+        
+    except APIError as e:
+        print(f"API错误: {e}")
+    except Exception as e:
+        print(f"未知错误: {e}")
+
+
+def example_with_data_processing():
+    """示例2: 带数据处理的搜索（CLI工具使用示例）"""
+    print("\n" + "=" * 80)
+    print("示例2: 带数据处理的搜索（CLI工具使用示例）")
+    print("=" * 80)
+    print("注意：此示例展示CLI工具的后处理功能，AI代理调用时应使用透明传递方式")
+    print("=" * 80)
+    
+    try:
+        # 初始化API客户端和数据处理
+        client = APIClient()
+        processor = DataProcessor()
+        
+        # 搜索研究报告（获取完整API响应）
+        query = "芯片行业分析报告"
+        response_data = client.search_reports(query)
+        
+        # 从响应中提取数据（CLI工具的后处理）
+        articles = response_data.get("data", [])
+        
+        print(f"搜索关键词: {query}")
+        print(f"完整API响应接收完成，提取到 {len(articles)} 篇研究报告数据")
+        
+        # 数据处理
+        # 1. 按日期排序（最新在前）
+        articles = processor.sort_articles(articles, sort_by="date", sort_order="desc")
+        
+        # 2. 提取关键信息
+        articles = processor.extract_key_info(articles)
+        
+        # 3. 分析结果
+        analysis = processor.analyze_articles(articles)
+        
+        print(f"\n分析结果:")
+        print(f"  总数量: {analysis.get('total_count')}")
+        print(f"  日期范围: {analysis.get('date_range', {}).get('start')} 到 {analysis.get('date_range', {}).get('end')}")
+        print(f"  行业分布: {analysis.get('industry_distribution')}")
+        print(f"  评级分布: {analysis.get('rating_distribution')}")
+        print(f"  平均摘要长度: {analysis.get('avg_summary_length'):.1f} 字符")
+        print(f"  分析覆盖率: {analysis.get('analysis_coverage'):.1%}")
+        
+        # 显示前3篇
+        print(f"\n前3篇研究报告:")
+        for i, article in enumerate(articles[:3], 1):
+            print(f"\n{i}. {article.get('title', '无标题')}")
+            print(f"   发布时间: {article.get('publish_date', '未知')}")
+            
+            extracted = article.get('extracted_info', {})
+            if extracted.get('rating'):
+                print(f"   投资评级: {extracted['rating']}")
+            if extracted.get('target_price'):
+                print(f"   目标价: {extracted['target_price']}元")
+            if extracted.get('industry'):
+                print(f"   所属行业: {extracted['industry']}")
+        
+        print("\n" + "=" * 80)
+        
+    except APIError as e:
+        print(f"API错误: {e}")
+    except Exception as e:
+        print(f"未知错误: {e}")
+
+
+def example_save_to_files():
+    """示例3: 保存到文件（CLI工具使用示例）"""
+    print("\n" + "=" * 80)
+    print("示例3: 保存到文件（CLI工具使用示例）")
+    print("=" * 80)
+    print("注意：此示例展示CLI工具的导出功能，AI代理调用时应使用透明传递方式")
+    print("=" * 80)
+    
+    try:
+        # 初始化API客户端和数据处理
+        client = APIClient()
+        processor = DataProcessor()
+        
+        # 搜索研究报告（获取完整API响应）
+        query = "新能源汽车投资分析"
+        response_data = client.search_reports(query)
+        
+        # 从响应中提取数据（CLI工具的后处理）
+        articles = response_data.get("data", [])
+        
+        print(f"搜索关键词: {query}")
+        print(f"完整API响应接收完成，提取到 {len(articles)} 篇研究报告数据")
+        
+        # 数据处理
+        articles = processor.sort_articles(articles, sort_by="relevance", sort_order="desc")
+        articles = processor.extract_key_info(articles)
+        
+        # 创建输出目录
+        output_dir = Path("example_output")
+        output_dir.mkdir(exist_ok=True)
+        
+        # 保存到不同格式
+        # 1. 保存到CSV
+        csv_path = output_dir / "research_reports.csv"
+        processor.save_to_csv(articles, str(csv_path))
+        print(f"  保存到CSV: {csv_path}")
+        
+        # 2. 保存到JSON
+        json_path = output_dir / "research_reports.json"
+        processor.save_to_json(articles, str(json_path))
+        print(f"  保存到JSON: {json_path}")
+        
+        # 3. 保存到Markdown
+        md_path = output_dir / "research_reports.md"
+        processor.save_to_markdown(articles, str(md_path))
+        print(f"  保存到Markdown: {md_path}")
+        
+        # 显示文件大小
+        print(f"\n生成的文件:")
+        for filepath in [csv_path, json_path, md_path]:
+            if filepath.exists():
+                size_kb = filepath.stat().st_size / 1024
+                print(f"  {filepath.name}: {size_kb:.1f} KB")
+        
+        print("\n" + "=" * 80)
+        
+    except APIError as e:
+        print(f"API错误: {e}")
+    except Exception as e:
+        print(f"未知错误: {e}")
+
+
+def example_batch_processing():
+    """示例4: 批量处理（响应透明传递示例）"""
+    print("\n" + "=" * 80)
+    print("示例4: 批量处理（响应透明传递示例）")
+    print("=" * 80)
+    print("注意：batch_search现在返回完整的API响应字典")
+    print("=" * 80)
+    
+    try:
+        # 初始化API客户端
+        client = APIClient()
+        
+        # 批量查询
+        queries = [
+            "人工智能行业趋势",
+            "芯片技术发展",
+            "新能源政策分析",
+            "医药创新研究"
+        ]
+        
+        print(f"批量处理 {len(queries)} 个查询:")
+        
+        # 批量搜索（现在返回完整的API响应字典）
+        batch_results = client.batch_search(queries, limit_per_query=3)
+        
+        total_articles = 0
+        for query, response_data in batch_results.items():
+            # 从每个响应中提取数据
+            articles = response_data.get("data", [])
+            count = len(articles)
+            total_articles += count
+            print(f"  {query}: {count} 篇研究报告")
+            
+            # 显示每篇的标题
+            for i, article in enumerate(articles[:2], 1):  # 只显示前2篇
+                title = article.get('title', '无标题')
+                if len(title) > 50:
+                    title = title[:47] + "..."
+                print(f"    {i}. {title}")
+            
+            if count > 2:
+                print(f"    ... 还有 {count - 2} 篇")
+        
+        print(f"\n总计: {total_articles} 篇研究报告")
+        
+        print("\n" + "=" * 80)
+        
+    except APIError as e:
+        print(f"API错误: {e}")
+    except Exception as e:
+        print(f"未知错误: {e}")
+
+
+def example_cli_usage():
+    """示例5: CLI使用方式"""
+    print("\n" + "=" * 80)
+    print("示例5: CLI使用方式")
+    print("=" * 80)
+    
+    print("CLI命令行使用示例:")
+    print()
+    print("1. 基本搜索:")
+    print("   python research_report_search.py -q \"人工智能行业研究报告\"")
+    print()
+    print("2. 限制结果数量:")
+    print("   python research_report_search.py -q \"芯片行业\" -l 5")
+    print()
+    print("3. 导出为CSV格式:")
+    print("   python research_report_search.py -q \"新能源汽车\" -o results.csv -f csv")
+    print()
+    print("4. 批量处理:")
+    print("   python research_report_search.py -i queries.txt -o ./results -f json")
+    print()
+    print("5. 时间范围搜索:")
+    print("   python research_report_search.py -q \"医药行业\" --date-from \"2024-01-01\" --date-to \"2024-03-31\"")
+    print()
+    print("6. 获取帮助:")
+    print("   python research_report_search.py -h")
+    print()
+    print("7. 测试API连接:")
+    print("   python research_report_search.py --test")
+    
+    print("\n" + "=" * 80)
+
+
+def example_curl_usage():
+    """示例6: curl使用方式"""
+    print("\n" + "=" * 80)
+    print("示例6: curl使用方式")
+    print("=" * 80)
+    
+    print("curl命令行使用示例:")
+    print()
+    print("1. 基本搜索 (Unix/Linux/macOS):")
+    print("   curl -X POST \"https://openapi.iwencai.com/v1/comprehensive/search\" \\")
+    print("     -H \"Content-Type: application/json\" \\")
+    print("     -H \"Authorization: Bearer $IWENCAI_API_KEY\" \\")
+    print("     -H \"X-Claw-Call-Type: normal\" \\")
+    print("     -H \"X-Claw-Skill-Id: report-search\" \\")
+    print("     -H \"X-Claw-Skill-Version: 2.0.0\" \\")
+    print("     -H \"X-Claw-Plugin-Id: none\" \\")
+    print("     -H \"X-Claw-Plugin-Version: none\" \\")
+    print("     -H \"X-Claw-Trace-Id: $(python -c 'import secrets; print(secrets.token_hex(32))')\" \\")
+    print("     -d '{")
+    print("       \"channels\": [\"report\"],")
+    print("       \"app_id\": \"AIME_SKILL\",")
+    print("       \"query\": \"人工智能行业研究报告\"")
+    print("     }'")
+    print()
+    print("2. Windows PowerShell:")
+    print("   $traceId = python -c \"import secrets; print(secrets.token_hex(32))\"")
+    print("   curl.exe -X POST \"https://openapi.iwencai.com/v1/comprehensive/search\" \\")
+    print("     -H \"Content-Type: application/json\" \\")
+    print("     -H \"Authorization: Bearer $env:IWENCAI_API_KEY\" \\")
+    print("     -H \"X-Claw-Call-Type: normal\" \\")
+    print("     -H \"X-Claw-Skill-Id: report-search\" \\")
+    print("     -H \"X-Claw-Skill-Version: 2.0.0\" \\")
+    print("     -H \"X-Claw-Plugin-Id: none\" \\")
+    print("     -H \"X-Claw-Plugin-Version: none\" \\")
+    print("     -H \"X-Claw-Trace-Id: $traceId\" \\")
+    print("     -d '{")
+    print("       \"channels\": [\"report\"],")
+    print("       \"app_id\": \"AIME_SKILL\",")
+    print("       \"query\": \"人工智能行业研究报告\"")
+    print("     }'")
+    print()
+    print("注意: 每次请求都会生成新的64字符Trace ID")
+    
+    print("\n" + "=" * 80)
+
+
+def main():
+    """主函数"""
+    print("研报搜索技能使用示例")
+    print("版本: 2.0.0")
+    print("规范: 符合iwencai-skill-creator要求")
+    print("=" * 80)
+    
+    # 检查API Key
+    if not os.getenv("IWENCAI_API_KEY"):
+        print("警告: 请先设置环境变量 IWENCAI_API_KEY")
+        print("示例: export IWENCAI_API_KEY=\"your_api_key_here\"")
+        print()
+        print("以下示例将模拟运行，不会实际调用API")
+        print("=" * 80)
+    
+    # 运行示例
+    example_basic_search()
+    example_with_data_processing()
+    example_save_to_files()
+    example_batch_processing()
+    example_cli_usage()
+    example_curl_usage()
+    
+    print("\n示例运行完成!")
+    print("请参考以上示例使用研报搜索技能。")
+
+
+if __name__ == "__main__":
+    main()

Skills/report-search/scripts/requirements.txt

@@ -0,0 +1,3 @@
+requests>=2.28.0
+pandas>=1.5.0
+numpy>=1.24.0

Skills/report-search/scripts/research_report_search.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+研报搜索技能主程序
+"""
+
+import sys
+import os
+
+# 添加当前目录到Python路径
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

Skills/report-search/scripts/setup.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+研报搜索技能安装配置
+"""
+
+import os
+import sys
+from setuptools import setup, find_packages
+
+# 读取版本信息
+with open(os.path.join(os.path.dirname(__file__), 'requirements.txt'), 'r', encoding='utf-8') as f:
+    requirements = [line.strip() for line in f if line.strip() and not line.startswith('#')]
+
+# 读取README
+with open(os.path.join(os.path.dirname(__file__), '..', 'README.md'), 'r', encoding='utf-8') as f:
+    long_description = f.read()
+
+setup(
+    name="research-report-search",
+    version="1.0.0",
+    description="研报搜索技能 - 搜索和分析财经研究报告",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author="研报搜索技能开发团队",
+    author_email="",
+    url="",
+    packages=find_packages(),
+    py_modules=[
+        'config',
+        'api_client',
+        'data_processor',
+        'cli',
+        'research_report_search'
+    ],
+    install_requires=requirements,
+    entry_points={
+        'console_scripts': [
+            'research-report-search=research_report_search:main',
+            'rrs=research_report_search:main',
+        ],
+    },
+    classifiers=[
+        'Development Status :: 4 - Beta',
+        'Intended Audience :: Financial and Insurance Industry',
+        'Topic :: Office/Business :: Financial :: Investment',
+        'License :: OSI Approved :: MIT License',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
+    ],
+    keywords='research report, financial analysis, investment, stock, finance',
+    python_requires='>=3.7',
+    project_urls={
+        'Documentation': 'https://github.com/example/research-report-search',
+        'Source': 'https://github.com/example/research-report-search',
+        'Tracker': 'https://github.com/example/research-report-search/issues',
+    },
+)
+
+
+def install_config():
+    """安装配置文件"""
+    import shutil
+    from pathlib import Path
+    
+    # 源配置文件路径
+    source_config = Path(__file__).parent / 'config.example.json'
+    
+    # 目标配置文件路径（用户目录）
+    home_dir = Path.home()
+    config_dir = home_dir / '.research_report_search'
+    config_dir.mkdir(exist_ok=True)
+    
+    target_config = config_dir / 'config.json'
+    
+    # 如果配置文件不存在，复制示例配置
+    if not target_config.exists() and source_config.exists():
+        shutil.copy2(source_config, target_config)
+        print(f"已创建配置文件: {target_config}")
+        print("请编辑该文件以配置您的API设置。")
+    else:
+        print(f"配置文件已存在: {target_config}")
+
+
+def check_dependencies():
+    """检查依赖"""
+    import subprocess
+    import importlib
+    
+    print("检查依赖...")
+    
+    # 检查Python版本
+    if sys.version_info < (3, 7):
+        print("错误: 需要Python 3.7或更高版本")
+        sys.exit(1)
+    
+    # 检查必要依赖
+    required_packages = ['requests', 'pandas', 'numpy']
+    
+    for package in required_packages:
+        try:
+            importlib.import_module(package)
+            print(f"  ✓ {package}")
+        except ImportError:
+            print(f"  ✗ {package} 未安装")
+            print(f"    请运行: pip install {package}")
+    
+    print("\n依赖检查完成。")
+
+
+if __name__ == "__main__":
+    # 安装时执行额外操作
+    if len(sys.argv) > 1 and sys.argv[1] == 'install':
+        print("研报搜索技能安装程序")
+        print("=" * 80)
+        
+        # 检查依赖
+        check_dependencies()
+        
+        # 安装配置文件
+        install_config()
+        
+        print("\n安装完成!")
+        print("\n使用说明:")
+        print("1. 设置API密钥环境变量:")
+        print("   export IWENCAI_API_KEY=\"your_api_key_here\"")
+        print("\n2. 基本使用:")
+        print("   research-report-search -q \"人工智能行业研究报告\"")
+        print("\n3. 获取帮助:")
+        print("   research-report-search -h")
+        
+    else:
+        # 正常setup.py执行
+        pass

Skills/report-search/scripts/test_basic.py

@@ -0,0 +1,418 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+研报搜索技能基础测试
+"""
+
+import os
+import sys
+import unittest
+import tempfile
+from pathlib import Path
+from unittest.mock import patch, MagicMock
+
+# 添加当前目录到Python路径
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from config import Config, get_config
+from data_processor import DataProcessor
+from api_client import APIClient, APIError
+
+
+class TestConfig(unittest.TestCase):
+    """配置模块测试"""
+    
+    def setUp(self):
+        """测试前准备"""
+        self.config = Config()
+    
+    def test_default_config(self):
+        """测试默认配置"""
+        self.assertEqual(self.config.get("api.base_url"), "https://openapi.iwencai.com")
+        self.assertEqual(self.config.get("api.endpoint"), "/v1/comprehensive/search")
+        self.assertEqual(self.config.get("search.channels"), ["report"])
+        self.assertEqual(self.config.get("search.app_id"), "AIME_SKILL")
+    
+    def test_get_api_url(self):
+        """测试获取API URL"""
+        api_url = self.config.get_api_url()
+        self.assertEqual(api_url, "https://openapi.iwencai.com/v1/comprehensive/search")
+    
+    def test_validation(self):
+        """测试配置验证"""
+        # 测试空配置
+        config = Config()
+        with self.assertRaises(ValueError):
+            config.config["api"]["base_url"] = ""
+            config.validate()
+    
+    def test_environment_variables(self):
+        """测试环境变量"""
+        with patch.dict(os.environ, {"LOG_LEVEL": "DEBUG"}):
+            config = Config()
+            self.assertEqual(config.get("logging.level"), "DEBUG")
+    
+    def test_config_file_loading(self):
+        """测试配置文件加载"""
+        # 创建临时配置文件
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
+            json.dump({
+                "api": {
+                    "timeout": 60
+                }
+            }, f)
+            config_file = f.name
+        
+        try:
+            config = Config(config_file)
+            self.assertEqual(config.get("api.timeout"), 60)
+        finally:
+            os.unlink(config_file)
+
+
+class TestDataProcessor(unittest.TestCase):
+    """数据处理模块测试"""
+    
+    def setUp(self):
+        """测试前准备"""
+        self.processor = DataProcessor()
+        self.test_articles = [
+            {
+                "title": "人工智能行业研究报告：买入评级，目标价120元",
+                "summary": "本报告分析了人工智能行业的发展趋势，包括技术突破、应用场景、市场规模等方面的内容。",
+                "url": "https://example.com/reports/ai-2024",
+                "publish_date": "2024-01-15 09:30:00"
+            },
+            {
+                "title": "芯片行业分析报告：增持评级",
+                "summary": "报告详细介绍了芯片行业的最新发展动态和投资机会。",
+                "url": "https://example.com/reports/chip-2024",
+                "publish_date": "2024-01-14 14:20:00"
+            },
+            {
+                "title": "新能源汽车行业报告",
+                "summary": "分析新能源汽车行业的发展前景和投资建议。",
+                "url": "https://example.com/reports/ev-2024",
+                "publish_date": "2024-01-13 11:15:00"
+            }
+        ]
+    
+    def test_filter_by_date(self):
+        """测试按日期过滤"""
+        # 过滤2024-01-14之后的文章
+        filtered = self.processor.filter_by_date(
+            self.test_articles,
+            date_from="2024-01-14"
+        )
+        self.assertEqual(len(filtered), 2)
+        
+        # 过滤2024-01-14到2024-01-15之间的文章
+        filtered = self.processor.filter_by_date(
+            self.test_articles,
+            date_from="2024-01-14",
+            date_to="2024-01-15"
+        )
+        self.assertEqual(len(filtered), 2)
+    
+    def test_filter_by_days(self):
+        """测试按最近N天过滤"""
+        # 注意：这个测试依赖于当前时间
+        # 这里我们主要测试函数是否能正常运行
+        filtered = self.processor.filter_by_days(self.test_articles, days=30)
+        self.assertIsInstance(filtered, list)
+    
+    def test_sort_articles(self):
+        """测试排序"""
+        # 按日期降序排序
+        sorted_articles = self.processor.sort_articles(
+            self.test_articles,
+            sort_by="date",
+            sort_order="desc"
+        )
+        self.assertEqual(sorted_articles[0]["title"], "人工智能行业研究报告：买入评级，目标价120元")
+        
+        # 按相关性排序
+        sorted_articles = self.processor.sort_articles(
+            self.test_articles,
+            sort_by="relevance",
+            sort_order="desc"
+        )
+        self.assertIsInstance(sorted_articles, list)
+    
+    def test_extract_key_info(self):
+        """测试提取关键信息"""
+        processed = self.processor.extract_key_info(self.test_articles)
+        
+        self.assertEqual(len(processed), 3)
+        
+        # 检查提取的信息
+        for article in processed:
+            self.assertIn("extracted_info", article)
+            extracted = article["extracted_info"]
+            
+            self.assertIn("rating", extracted)
+            self.assertIn("target_price", extracted)
+            self.assertIn("industry", extracted)
+            self.assertIn("has_analysis", extracted)
+    
+    def test_save_to_csv(self):
+        """测试保存到CSV"""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            csv_path = Path(tmpdir) / "test.csv"
+            self.processor.save_to_csv(self.test_articles, str(csv_path))
+            
+            self.assertTrue(csv_path.exists())
+            self.assertGreater(csv_path.stat().st_size, 0)
+    
+    def test_save_to_json(self):
+        """测试保存到JSON"""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            json_path = Path(tmpdir) / "test.json"
+            self.processor.save_to_json(self.test_articles, str(json_path))
+            
+            self.assertTrue(json_path.exists())
+            
+            # 验证JSON格式
+            with open(json_path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+                self.assertIsInstance(data, list)
+                self.assertEqual(len(data), 3)
+    
+    def test_save_to_markdown(self):
+        """测试保存到Markdown"""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            md_path = Path(tmpdir) / "test.md"
+            self.processor.save_to_markdown(self.test_articles, str(md_path))
+            
+            self.assertTrue(md_path.exists())
+            
+            # 验证Markdown内容
+            with open(md_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+                self.assertIn("# 研究报告汇总", content)
+    
+    def test_analyze_articles(self):
+        """测试分析研究报告"""
+        processed = self.processor.extract_key_info(self.test_articles)
+        analysis = self.processor.analyze_articles(processed)
+        
+        self.assertIn("total_count", analysis)
+        self.assertEqual(analysis["total_count"], 3)
+        
+        self.assertIn("industry_distribution", analysis)
+        self.assertIn("rating_distribution", analysis)
+        self.assertIn("avg_summary_length", analysis)
+        self.assertIn("analysis_coverage", analysis)
+
+
+class TestAPIClient(unittest.TestCase):
+    """API客户端模块测试"""
+    
+    def setUp(self):
+        """测试前准备"""
+        # 模拟环境变量
+        self.env_patch = patch.dict(os.environ, {"IWENCAI_API_KEY": "test_key"})
+        self.env_patch.start()
+        
+        self.client = APIClient()
+    
+    def tearDown(self):
+        """测试后清理"""
+        self.env_patch.stop()
+    
+    def test_initialization(self):
+        """测试初始化"""
+        self.assertEqual(self.client.api_key, "test_key")
+        self.assertEqual(self.client.api_url, "https://openapi.iwencai.com/v1/comprehensive/search")
+    
+    @patch('requests.post')
+    def test_search_reports_success(self, mock_post):
+        """测试搜索研究报告成功"""
+        # 模拟API响应
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "data": [
+                {
+                    "title": "测试报告",
+                    "summary": "测试摘要",
+                    "url": "https://example.com/test",
+                    "publish_date": "2024-01-01 00:00:00"
+                }
+            ]
+        }
+        mock_post.return_value = mock_response
+        
+        # 调用搜索
+        articles = self.client.search_reports("测试", limit=5)
+        
+        # 验证结果
+        self.assertEqual(len(articles), 1)
+        self.assertEqual(articles[0]["title"], "测试报告")
+        
+        # 验证请求参数
+        mock_post.assert_called_once()
+        call_args = mock_post.call_args
+        self.assertEqual(call_args[0][0], "https://openapi.iwencai.com/v1/comprehensive/search")
+        
+        # 验证请求头
+        headers = call_args[1]['headers']
+        self.assertEqual(headers['Content-Type'], 'application/json')
+        self.assertEqual(headers['Authorization'], 'Bearer test_key')
+        
+        # 验证请求体
+        json_data = call_args[1]['json']
+        self.assertEqual(json_data['channels'], ['report'])
+        self.assertEqual(json_data['app_id'], 'AIME_SKILL')
+        self.assertEqual(json_data['query'], '测试')
+    
+    @patch('requests.post')
+    def test_search_reports_api_error(self, mock_post):
+        """测试API错误"""
+        # 模拟API错误响应
+        mock_response = MagicMock()
+        mock_response.status_code = 401
+        mock_response.json.return_value = {
+            "message": "认证失败"
+        }
+        mock_post.return_value = mock_response
+        
+        # 验证抛出APIError
+        with self.assertRaises(APIError) as context:
+            self.client.search_reports("测试")
+        
+        self.assertIn("认证失败", str(context.exception))
+    
+    @patch('requests.post')
+    def test_search_reports_network_error(self, mock_post):
+        """测试网络错误"""
+        # 模拟网络错误
+        mock_post.side_effect = ConnectionError("网络连接失败")
+        
+        # 验证抛出APIError
+        with self.assertRaises(APIError) as context:
+            self.client.search_reports("测试")
+        
+        self.assertIn("网络连接失败", str(context.exception))
+    
+    def test_batch_search(self):
+        """测试批量搜索"""
+        # 模拟search_reports方法
+        with patch.object(self.client, 'search_reports') as mock_search:
+            mock_search.return_value = [
+                {"title": "测试报告1"},
+                {"title": "测试报告2"}
+            ]
+            
+            # 调用批量搜索
+            queries = ["查询1", "查询2"]
+            results = self.client.batch_search(queries, limit_per_query=2)
+            
+            # 验证结果
+            self.assertEqual(len(results), 2)
+            self.assertIn("查询1", results)
+            self.assertIn("查询2", results)
+            self.assertEqual(len(results["查询1"]), 2)
+            self.assertEqual(len(results["查询2"]), 2)
+            
+            # 验证调用次数
+            self.assertEqual(mock_search.call_count, 2)
+
+
+class TestIntegration(unittest.TestCase):
+    """集成测试"""
+    
+    def setUp(self):
+        """测试前准备"""
+        # 模拟环境变量
+        self.env_patch = patch.dict(os.environ, {"IWENCAI_API_KEY": "test_key"})
+        self.env_patch.start()
+    
+    def tearDown(self):
+        """测试后清理"""
+        self.env_patch.stop()
+    
+    @patch('requests.post')
+    def test_end_to_end_workflow(self, mock_post):
+        """测试端到端工作流程"""
+        # 模拟API响应
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "data": [
+                {
+                    "title": "人工智能报告",
+                    "summary": "人工智能行业分析",
+                    "url": "https://example.com/ai",
+                    "publish_date": "2024-01-15 09:30:00"
+                },
+                {
+                    "title": "芯片报告",
+                    "summary": "芯片行业分析",
+                    "url": "https://example.com/chip",
+                    "publish_date": "2024-01-14 14:20:00"
+                }
+            ]
+        }
+        mock_post.return_value = mock_response
+        
+        # 初始化组件
+        client = APIClient()
+        processor = DataProcessor()
+        
+        # 搜索研究报告
+        articles = client.search_reports("人工智能", limit=5)
+        
+        # 数据处理
+        processed = processor.extract_key_info(articles)
+        sorted_articles = processor.sort_articles(processed, sort_by="date", sort_order="desc")
+        
+        # 验证结果
+        self.assertEqual(len(sorted_articles), 2)
+        self.assertEqual(sorted_articles[0]["title"], "人工智能报告")
+        
+        # 验证提取的信息
+        self.assertIn("extracted_info", sorted_articles[0])
+        extracted = sorted_articles[0]["extracted_info"]
+        self.assertIn("rating", extracted)
+        self.assertIn("target_price", extracted)
+        self.assertIn("industry", extracted)
+        self.assertIn("has_analysis", extracted)
+
+
+def run_tests():
+    """运行测试"""
+    # 创建测试套件
+    suite = unittest.TestSuite()
+    
+    # 添加测试类
+    suite.addTest(unittest.makeSuite(TestConfig))
+    suite.addTest(unittest.makeSuite(TestDataProcessor))
+    suite.addTest(unittest.makeSuite(TestAPIClient))
+    suite.addTest(unittest.makeSuite(TestIntegration))
+    
+    # 运行测试
+    runner = unittest.TextTestRunner(verbosity=2)
+    result = runner.run(suite)
+    
+    return result
+
+
+if __name__ == "__main__":
+    print("研报搜索技能基础测试")
+    print("=" * 80)
+    
+    # 运行测试
+    result = run_tests()
+    
+    # 输出测试结果
+    print("\n" + "=" * 80)
+    print(f"测试结果: {result.testsRun} 个测试用例")
+    print(f"通过: {result.testsRun - len(result.failures) - len(result.errors)}")
+    print(f"失败: {len(result.failures)}")
+    print(f"错误: {len(result.errors)}")
+    
+    if result.failures or result.errors:
+        sys.exit(1)
+    else:
+        print("\n所有测试通过!")

Skills/report-search/scripts/test_queries.txt

@@ -0,0 +1,43 @@
+# 研报搜索测试查询文件
+# 每行一个查询关键词
+
+人工智能行业研究报告
+芯片技术发展分析
+新能源汽车投资前景
+医药创新研究进展
+金融科技发展趋势
+5G通信行业分析
+云计算市场报告
+半导体产业研究
+消费行业投资分析
+智能制造发展报告
+
+# 行业趋势分析
+人工智能
+芯片
+新能源
+医药
+金融
+科技
+制造
+消费
+
+# 公司分析
+腾讯控股分析
+阿里巴巴研究
+华为技术分析
+比亚迪研究报告
+宁德时代分析
+茅台投资价值
+美团点评研究
+京东集团分析
+
+# 投资主题
+碳中和投资机会
+数字经济趋势
+专精特新企业
+国产替代机会
+消费升级趋势
+科技创新投资
+绿色能源发展
+数字化转型

app/__init__.py

@@ -0,0 +1,2 @@
+"""Fin-DataPilot backend package."""
+__version__ = "0.1.0"

app/agent/graph.py

@@ -0,0 +1,180 @@
+"""LangGraph StateGraph assembly + streaming entry point."""
+from __future__ import annotations
+
+import logging
+from typing import Any, AsyncIterator
+
+from langgraph.graph import END, StateGraph
+
+from app.agent.nodes.executor import executor_node
+from app.agent.nodes.reflector import reflector_node
+from app.agent.nodes.skill_router import skill_router_node
+from app.agent.nodes.synthesizer import synthesize
+from app.agent.state import AgentState, EV_DONE, EV_ERROR
+from app.config import get_settings
+from app.skills.registry import REGISTRY
+
+logger = logging.getLogger(__name__)
+
+
+def _build_graph() -> Any:
+    g = StateGraph(AgentState)
+    g.add_node("skill_router", skill_router_node)
+    g.add_node("executor", executor_node)
+    g.add_node("reflector", reflector_node)
+    g.add_node("synthesizer", lambda s: s)  # placeholder; streaming handled outside
+
+    g.set_entry_point("skill_router")
+
+    # After router: if final_answer was set, go to synthesizer; else go to executor
+    def _after_router(state: AgentState) -> str:
+        if state.get("error"):
+            return "synthesizer"
+        if state.get("final_answer"):
+            return "synthesizer"
+        return "executor"
+
+    g.add_conditional_edges("skill_router", _after_router, {
+        "executor": "executor",
+        "synthesizer": "synthesizer",
+    })
+
+    # After executor: always go to reflector
+    g.add_edge("executor", "reflector")
+
+    # After reflector: if more rounds needed AND round limit not reached, loop back to router
+    def _after_reflector(state: AgentState) -> str:
+        verdict = state.get("reflection_verdict", "sufficient")
+        rounds = state.get("rounds_used", 0)
+        max_rounds = get_settings().agent_max_reflect_rounds
+        if verdict == "need_more" and rounds < max_rounds:
+            return "skill_router"
+        return "synthesizer"
+
+    g.add_conditional_edges("reflector", _after_reflector, {
+        "skill_router": "skill_router",
+        "synthesizer": "synthesizer",
+    })
+
+    g.add_edge("synthesizer", END)
+
+    return g.compile()
+
+
+_GRAPH = None
+
+
+def get_graph() -> Any:
+    global _GRAPH
+    if _GRAPH is None:
+        _GRAPH = _build_graph()
+    return _GRAPH
+
+
+# ---------- Public streaming entry point ----------
+
+
+async def run_agent_stream(
+    user_query: str,
+    history: list[dict[str, Any]],
+    session_id: str,
+) -> AsyncIterator[dict[str, Any]]:
+    """Stream agent events for a single user turn."""
+    from app.agent.state import (
+        EV_MESSAGE_FINAL,
+        EV_REFLECTION,
+        EV_THINK,
+        EV_TOOL_CALL,
+        EV_TOOL_RESULT,
+    )
+    from app.utils.trace import generate_trace_id
+
+    if not REGISTRY.list_specs():
+        yield {"event": EV_ERROR, "data": {"message": "No skills registered"}}
+        yield {"event": EV_DONE, "data": {}}
+        return
+
+    trace_id = generate_trace_id()
+    init_state: AgentState = {
+        "user_query": user_query,
+        "session_id": session_id,
+        "history": history,
+        "tool_calls": [],
+        "rounds_used": 0,
+        "reflection_verdict": "need_more",
+        "trace_id": trace_id,
+    }
+    yield {"event": EV_THINK, "data": {"step": "entry", "text": f"开始处理：{user_query}", "trace_id": trace_id}}
+
+    graph = get_graph()
+    final_state: AgentState = dict(init_state)
+
+    try:
+        async for event in graph.astream(init_state):
+            # event is dict {node_name: node_output}
+            for node_name, node_out in event.items():
+                if not isinstance(node_out, dict):
+                    continue
+                final_state.update(node_out)
+                # Stream per-node events
+                if node_name == "skill_router":
+                    tc = (node_out.get("tool_calls") or [])
+                    if tc and tc[-1].get("result") is None:
+                        last = tc[-1]
+                        yield {
+                            "event": EV_TOOL_CALL,
+                            "data": {
+                                "name": last["name"],
+                                "args": last.get("args", {}),
+                                "trace_id": last.get("trace_id", ""),
+                            },
+                        }
+                    if node_out.get("final_answer"):
+                        yield {
+                            "event": EV_THINK,
+                            "data": {"step": "router_final", "text": "直接生成最终答案"},
+                        }
+                elif node_name == "executor":
+                    tc = (node_out.get("tool_calls") or [])
+                    if tc:
+                        last = tc[-1]
+                        yield {
+                            "event": EV_TOOL_RESULT,
+                            "data": {
+                                "name": last["name"],
+                                "ok": last.get("ok", False),
+                                "duration_ms": last.get("duration_ms", 0),
+                                "trace_id": last.get("trace_id", ""),
+                                "result": last.get("result"),
+                                "error": last.get("error"),
+                            },
+                        }
+                elif node_name == "reflector":
+                    yield {
+                        "event": EV_REFLECTION,
+                        "data": {
+                            "verdict": node_out.get("reflection_verdict", "sufficient"),
+                            "reason": node_out.get("reflection", ""),
+                        },
+                    }
+    except Exception as exc:  # noqa: BLE001
+        logger.exception("agent graph execution failed")
+        yield {"event": EV_ERROR, "data": {"message": f"Agent 执行失败: {exc}", "trace_id": trace_id}}
+
+    # If the router produced a final answer directly (no synthesizer streaming)
+    if final_state.get("final_answer") and not any(
+        True for _ in []
+    ):  # placeholder check
+        yield {
+            "event": EV_MESSAGE_FINAL,
+            "data": {
+                "content": final_state["final_answer"],
+                "tool_calls": final_state.get("tool_calls", []),
+            },
+        }
+    else:
+        # Stream synthesizer output
+        async for ev in synthesize(final_state):
+            yield ev
+
+    yield {"event": EV_DONE, "data": {"trace_id": trace_id}}