unified-search

Original source / Raw SKILL.md

---
name: unified-search
description: 统一搜索技能！中文用百度，英文用 DuckDuckGo，加密货币用 CoinGecko
---

# 🔍 Unified Search - 统一搜索技能

**智能融合多种搜索引擎，一个脚本搞定所有搜索！**
- 🇨🇳 中文查询 → 自动用百度
- 🇺🇸 英文查询 → 自动用 DuckDuckGo
- 💰 加密货币 → 自动用 CoinGecko 实时价格

---

## 🚀 快速开始

### 方式1：使用统一智能搜索脚本（最推荐 ⭐⭐⭐⭐⭐⭐）

**自动选择最佳搜索引擎！** 一行命令，智能搞定！

```bash
cd skills/baidu-search

# 中文搜索 → 自动用百度
python scripts/unified_search.py "Python 教程" --format

# 英文搜索 → 自动用 DuckDuckGo
python scripts/unified_search.py "Python tutorial" --format

# 加密货币 → 自动用 CoinGecko
python scripts/unified_search.py "btc价格" --format
```

### 方式2：使用 Playwright 浏览器搜索（推荐 ⭐⭐⭐⭐⭐）

最稳定、最可靠的方式，使用 ClawX 内置的 browser 工具：

```javascript
// 1. 启动浏览器
browser(action="start")

// 2. 打开百度或 Bing
browser(action="open", targetUrl="https://www.baidu.com")
// 或 browser(action="open", targetUrl="https://www.bing.com")

// 3. 获取页面快照
browser(action="snapshot")

// 4. 在搜索框输入关键词（找到搜索框的 ref，如 e12）
browser(action="act", request={
  kind: "type",
  ref: "e12",
  text: "搜索词"
})

// 5. 按回车搜索
browser(action="act", request={
  kind: "press",
  ref: "e12",
  key: "Enter"
})

// 6. 获取搜索结果
browser(action="snapshot")
```

### 方式3：使用智能 Python 脚本搜索（备选）

```bash
cd skills/baidu-search
python scripts/smart_search.py "你的搜索词" --format
```

### 方式4：使用原始百度 Python 脚本

```bash
cd skills/baidu-search
python scripts/baidu_search.py "你的搜索词" --format
```

---

## 📋 功能对比

| 功能 | 统一智能搜索 | Playwright 浏览器 | 智能脚本 | 原始百度 |
|------|------------|-----------------|---------|---------|
| 中文自动用百度 | ✅ | ⭐⭐⭐⭐⭐ 手动 | ✅ | ✅ |
| 英文自动用 DDG | ✅ | ⭐⭐⭐⭐⭐ 手动 | ❌ | ❌ |
| 加密货币实时价 | ✅ | ❌ 需手动 | ✅ | ❌ |
| 多数据源集成 | ✅ 百度+DDG+API | ❌ 单一引擎 | ✅ 百度+Bing+API | ❌ 仅百度 |
| 易用性 | ⭐⭐⭐⭐⭐ 一行命令 | ⭐⭐⭐⭐ 需多步 | ⭐⭐⭐⭐⭐ 一行 | ⭐⭐⭐⭐⭐ 一行 |
| 推荐度 | ⭐⭐⭐⭐⭐⭐ 首选 | ⭐⭐⭐⭐⭐ 备选 | ⭐⭐⭐⭐ 备选 | ⭐⭐⭐ 备选 |

---

## 🎯 触发模式

| 触发短语 | 说明 |
|---------|------|
| 搜索[查询内容] | 使用统一智能搜索 |
| 统一搜索[查询内容] | 使用统一智能搜索 |
| 百度搜索[查询内容] | 使用百度搜索 |
| 浏览器搜索[查询内容] | 使用 Playwright 搜索 |
| baidu-search [查询内容] | 使用百度搜索 |

---

## 💡 最佳实践

### 日常搜索推荐流程

1. **首选**：`unified_search.py` - 自动选择，最方便
2. **备选**：Playwright 浏览器搜索 - 最稳定，可处理验证码
3. **备选**：`smart_search.py` - 百度 + Bing 双保险

### 选择指南

| 场景 | 推荐方式 |
|------|---------|
| 快速搜索任何内容 | unified_search.py |
| 中文内容搜索 | unified_search.py → 百度 |
| 英文内容搜索 | unified_search.py → DuckDuckGo |
| BTC/ETH 价格查询 | unified_search.py → CoinGecko |
| 需要完整网页截图 | Playwright 浏览器搜索 |

---

## 🛠️ 故障排除

### 问题：统一搜索脚本找不到模块

**解决方案**：确保 ddg-search 技能存在于 skills 目录中

```bash
# 检查目录结构
ls C:\Users\opens\.openclaw\workspace\skills\
# 应该能看到 baidu-search 和 ddg-search
```

### 问题：DuckDuckGo 搜索失败

**解决方案**：安装 duckduckgo-search 库

```bash
pip install duckduckgo-search
# 或者在 ddg-search 目录中安装
cd skills/ddg-search
pip install -r requirements.txt
```

### 问题：百度搜索遇到验证码

**解决方案**：
- 使用 Playwright 浏览器搜索方式（可以人工处理验证码）
- 或者使用 unified_search.py，它会自动降级到 DuckDuckGo

---

## 📁 目录结构

```
skills/baidu-search/
├── SKILL.md                      # 本文件
├── README.md                     # 用户友好的说明
├── OPTIMIZATION_SUMMARY.md       # 优化总结
├── requirements.txt              # Python 依赖
├── example_usage.js              # 使用示例
├── quick_test.py                 # 快速测试
└── scripts/
    ├── unified_search.py         # ⭐ 统一智能搜索（推荐）
    ├── smart_search.py           # 智能搜索脚本
    └── baidu_search.py           # 原始百度脚本
```

---

## 🔧 依赖安装

如需使用 Python 脚本搜索方式：

```bash
cd skills/baidu-search
pip install requests beautifulsoup4

# 如果使用统一搜索，还需要安装 DuckDuckGo 依赖
cd ../ddg-search
pip install -r requirements.txt
```

---

## ✨ 统一搜索特色功能

1. **🧠 智能语言检测**
   - 自动识别中文/英文查询
   - 选择最佳搜索引擎

2. **💰 加密货币支持**
   - BTC/ETH/比特币/以太坊自动识别
   - CoinGecko 实时价格
   - 美元 + 人民币双币种

3. **🔄 自动 Fallback**
   - 百度失败 → 自动用 DDG
   - DDG 失败 → 自动用百度
   - 双重保障

4. **📊 标明来源**
   - 每个结果显示来源（百度/DuckDuckGo/CoinGecko）
   - 清楚知道数据来自哪里

---

**统一搜索，一个脚本搞定所有！首选 unified_search.py！** 🎉


---

## Referenced Files

> The following files are referenced in this skill and included for context.

### scripts/unified_search.py

```python
#!/usr/bin/env python3
"""
统一搜索脚本 - 智能融合百度和 DuckDuckGo
中文查询用百度，英文查询用 DDG，加密货币用 CoinGecko
"""
import sys
import io
import json
import re
import os

# 修复 Windows 控制台编码问题
sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')

# 添加脚本路径以便导入
baidu_script_path = os.path.join(os.path.dirname(__file__))
if baidu_script_path not in sys.path:
    sys.path.insert(0, baidu_script_path)

def is_chinese_query(query):
    """判断是否为中文查询"""
    return any('\u4e00' <= char <= '\u9fff' for char in query)

def is_crypto_query(query):
    """判断是否是加密货币相关查询"""
    crypto_keywords = ['btc', 'bitcoin', '比特币', 'eth', 'ethereum', '以太坊',
                       'crypto', '加密货币', '价格', 'price', '行情']
    query_lower = query.lower()
    return any(kw in query_lower for kw in crypto_keywords)

def search_with_smart_script(query):
    """使用智能搜索脚本（支持加密货币和百度）"""
    try:
        import subprocess
        script_path = os.path.join(baidu_script_path, 'smart_search.py')
        result = subprocess.run(
            [sys.executable, script_path, query],
            capture_output=True,
            text=True,
            encoding='utf-8'
        )
        if result.returncode == 0:
            return json.loads(result.stdout)
    except Exception as e:
        print(f"智能搜索失败: {e}", file=sys.stderr)
    return []

def search_with_ddg(query):
    """使用 DuckDuckGo 搜索"""
    try:
        import subprocess
        ddg_path = os.path.join(
            os.path.dirname(os.path.dirname(baidu_script_path)),
            'ddg-search', 'scripts', 'ddg_search.py'
        )
        result = subprocess.run(
            [sys.executable, ddg_path, query],
            capture_output=True,
            text=True,
            encoding='utf-8'
        )
        if result.returncode == 0:
            results = json.loads(result.stdout)
            # 添加来源标记
            for r in results:
                r['source'] = 'DuckDuckGo'
            return results
    except Exception as e:
        print(f"DDG搜索失败: {e}", file=sys.stderr)
    return []

def unified_search(query):
    """统一搜索入口"""
    print(f"🔍 统一搜索: {query}", file=sys.stderr)
    
    # 1. 检查是否是加密货币查询
    if is_crypto_query(query):
        print("检测到加密货币查询，使用智能搜索...", file=sys.stderr)
        results = search_with_smart_script(query)
        if results:
            return results
    
    # 2. 判断语言类型
    if is_chinese_query(query):
        print("检测到中文查询，使用百度搜索...", file=sys.stderr)
        results = search_with_smart_script(query)
        if results:
            return results
        # 百度失败，降级到 DDG
        print("百度搜索失败，尝试 DuckDuckGo...", file=sys.stderr)
        return search_with_ddg(query)
    else:
        print("检测到英文查询，使用 DuckDuckGo...", file=sys.stderr)
        results = search_with_ddg(query)
        if results:
            return results
        # DDG 失败，降级到百度
        print("DuckDuckGo 搜索失败，尝试百度...", file=sys.stderr)
        return search_with_smart_script(query)

def print_results_formatted(results):
    """格式化输出结果"""
    if not results:
        print("未找到搜索结果")
        return
        
    for i, result in enumerate(results, 1):
        if 'error' in result:
            print(f"❌ {result['error']}")
            if 'suggestion' in result:
                print(f"💡 {result['suggestion']}")
            continue
            
        source = result.get('source', '')
        source_tag = f" [{source}]" if source else ""
        
        print(f"\n{i}. {result.get('title', '无标题')}{source_tag}")
        if result.get('url'):
            print(f"   🔗 {result['url']}")
        if result.get('snippet'):
            snippet = result['snippet'][:250] + ('...' if len(result['snippet']) > 250 else '')
            print(f"   📝 {snippet}")

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print(json.dumps({"error": "Please provide a search query"}))
        sys.exit(1)
    
    query = " ".join(sys.argv[1:])
    results = unified_search(query)
    
    if '--format' in sys.argv or '-f' in sys.argv:
        print_results_formatted(results)
    else:
        print(json.dumps(results, ensure_ascii=False))

```

### scripts/smart_search.py

```python
#!/usr/bin/env python3
"""
智能搜索脚本 - 集成多种数据源
支持：百度搜索、Bing搜索、CoinGecko加密货币价格等
"""
import sys
import io
import json
import urllib.parse
import requests
import re
from bs4 import BeautifulSoup

# 修复 Windows 控制台编码问题
sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')

def is_crypto_query(query):
    """判断是否是加密货币相关查询"""
    crypto_keywords = ['btc', 'bitcoin', '比特币', 'eth', 'ethereum', '以太坊',
                       'crypto', '加密货币', '价格', 'price', '行情']
    query_lower = query.lower()
    return any(kw in query_lower for kw in crypto_keywords)

def get_crypto_price(query):
    """从 CoinGecko 获取加密货币实时价格"""
    try:
        # 确定要查询的币种
        coin_id = 'bitcoin'  # 默认 BTC
        if 'eth' in query.lower() or '以太坊' in query:
            coin_id = 'ethereum'
        
        url = f"https://api.coingecko.com/api/v3/simple/price?ids={coin_id}&vs_currencies=usd,cny&include_24hr_change=true&include_market_cap=true"
        response = requests.get(url, timeout=10)
        data = response.json()
        
        if coin_id in data:
            coin_data = data[coin_id]
            coin_name = "比特币" if coin_id == 'bitcoin' else "以太坊"
            symbol = "BTC" if coin_id == 'bitcoin' else "ETH"
            
            return [{
                "title": f"📊 {coin_name} ({symbol}) 实时价格",
                "url": "https://www.coingecko.com",
                "snippet": (
                    f"💰 美元: ${coin_data.get('usd', 'N/A'):,} USD | "
                    f"💴 人民币: ¥{coin_data.get('cny', 'N/A'):,} CNY | "
                    f"📈 24h变化: {coin_data.get('usd_24h_change', 0):+.2f}%"
                ),
                "source": "CoinGecko",
                "is_realtime": True
            }]
    except Exception as e:
        print(f"获取加密货币价格失败: {e}", file=sys.stderr)
    
    return []

def search_bing(query, max_results=5):
    """使用 Bing 搜索作为备选"""
    try:
        search_url = f"https://www.bing.com/search?q={urllib.parse.quote(query)}"
        headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
        }
        response = requests.get(search_url, headers=headers, timeout=15)
        response.encoding = 'utf-8'
        soup = BeautifulSoup(response.text, 'html.parser')
        
        results = []
        for result in soup.find_all('li', class_='b_algo'):
            title_elem = result.find('h2')
            link_elem = title_elem.find('a') if title_elem else None
            snippet_elem = result.find('p')
            
            if title_elem and link_elem:
                results.append({
                    "title": link_elem.get_text(strip=True),
                    "url": link_elem.get('href', ''),
                    "snippet": snippet_elem.get_text(strip=True) if snippet_elem else '',
                    "source": "Bing"
                })
                if len(results) >= max_results:
                    break
        
        return results
    except Exception as e:
        print(f"Bing搜索失败: {e}", file=sys.stderr)
        return []

def search_baidu(query, max_results=10):
    """使用百度搜索"""
    try:
        search_url = f"https://www.baidu.com/s?wd={urllib.parse.quote(query)}&ie=utf-8"
        headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
            'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8',
        }
        
        session = requests.Session()
        response = session.get(search_url, headers=headers, timeout=15, allow_redirects=True)
        
        # 检查是否有验证
        if 'verify' in response.url or '验证码' in response.text[:500]:
            return []
        
        response.encoding = 'utf-8'
        soup = BeautifulSoup(response.text, 'html.parser')
        
        results = []
        for result in soup.find_all('div', class_='c-container'):
            title_elem = result.find('h3')
            if not title_elem:
                continue
            link_elem = title_elem.find('a')
            if not link_elem:
                continue
                
            title = link_elem.get_text(strip=True)
            url = link_elem.get('href', '')
            snippet = ""
            
            snippet_elem = result.find('div', class_='c-abstract')
            if snippet_elem:
                snippet = snippet_elem.get_text(strip=True)
            
            if url.startswith('//'):
                url = 'https:' + url
                
            if title and url and url.startswith('http'):
                results.append({
                    "title": title,
                    "url": url,
                    "snippet": snippet,
                    "source": "百度"
                })
                if len(results) >= max_results:
                    break
        
        return results
    except Exception as e:
        print(f"百度搜索失败: {e}", file=sys.stderr)
        return []

def smart_search(query):
    """智能搜索 - 根据查询类型选择最佳数据源"""
    all_results = []
    
    # 1. 检查是否是加密货币查询
    if is_crypto_query(query):
        print("检测到加密货币查询，使用 CoinGecko API...", file=sys.stderr)
        crypto_results = get_crypto_price(query)
        all_results.extend(crypto_results)
    
    # 2. 尝试百度搜索
    print("尝试百度搜索...", file=sys.stderr)
    baidu_results = search_baidu(query, max_results=5)
    all_results.extend(baidu_results)
    
    # 3. 如果百度结果少，补充 Bing 搜索
    if len(all_results) < 3:
        print("补充 Bing 搜索...", file=sys.stderr)
        bing_results = search_bing(query, max_results=5)
        all_results.extend(bing_results)
    
    # 4. 如果都没有结果，返回建议
    if not all_results:
        return [{
            "title": "💡 建议使用浏览器搜索",
            "url": "https://www.bing.com",
            "snippet": "建议使用 ClawX 的 browser 工具进行搜索，可以获得更完整的结果。",
            "suggestion": "browser"
        }]
    
    return all_results

def print_results_formatted(results):
    """格式化输出结果"""
    if not results:
        print("未找到搜索结果")
        return
        
    for i, result in enumerate(results, 1):
        if 'error' in result:
            print(f"❌ {result['error']}")
            if 'suggestion' in result:
                print(f"💡 {result['suggestion']}")
            continue
            
        source = result.get('source', '')
        source_tag = f" [{source}]" if source else ""
        
        print(f"\n{i}. {result.get('title', '无标题')}{source_tag}")
        if result.get('url'):
            print(f"   🔗 {result['url']}")
        if result.get('snippet'):
            snippet = result['snippet'][:250] + ('...' if len(result['snippet']) > 250 else '')
            print(f"   📝 {snippet}")

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print(json.dumps({"error": "Please provide a search query"}))
        sys.exit(1)
    
    query = " ".join(sys.argv[1:])
    results = smart_search(query)
    
    if '--format' in sys.argv or '-f' in sys.argv:
        print_results_formatted(results)
    else:
        print(json.dumps(results, ensure_ascii=False))

```

### scripts/baidu_search.py

```python
#!/usr/bin/env python3
import sys
import io
import json
import urllib.parse
import requests
import re
from bs4 import BeautifulSoup

# 修复 Windows 控制台编码问题
sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')

def search_baidu(query, max_results=10):
    """使用百度搜索 - 优化版本"""
    try:
        # 百度搜索URL
        search_url = f"https://www.baidu.com/s?wd={urllib.parse.quote(query)}&ie=utf-8&tn=baidu"
        
        # 设置请求头，模拟真实浏览器
        headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8',
            'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8',
            'Accept-Encoding': 'gzip, deflate, br',
            'Connection': 'keep-alive',
            'Upgrade-Insecure-Requests': '1',
            'Sec-Fetch-Dest': 'document',
            'Sec-Fetch-Mode': 'navigate',
            'Sec-Fetch-Site': 'none',
            'Cache-Control': 'max-age=0',
        }
        
        print(f"正在搜索: {query}", file=sys.stderr)
        
        # 发送请求
        session = requests.Session()
        response = session.get(search_url, headers=headers, timeout=15, allow_redirects=True)
        print(f"响应状态码: {response.status_code}", file=sys.stderr)
        print(f"最终URL: {response.url}", file=sys.stderr)
        
        # 检查是否有验证页面
        if 'verify' in response.url or '验证码' in response.text[:500]:
            return [{
                "error": "百度需要人机验证",
                "suggestion": "请使用浏览器搜索方式（Playwright），或者直接访问 https://www.baidu.com",
                "alternative": "使用 browser 工具进行搜索"
            }]
        
        response.encoding = 'utf-8'
        
        # 解析HTML
        soup = BeautifulSoup(response.text, 'html.parser')
        
        results = []
        
        # ==========================================
        # 策略1: 查找百度标准搜索结果 (c-container)
        # ==========================================
        print("策略1: 查找标准搜索结果...", file=sys.stderr)
        
        for result in soup.find_all('div', class_='c-container'):
            try:
                # 查找标题
                title_elem = result.find('h3')
                if not title_elem:
                    continue
                    
                link_elem = title_elem.find('a')
                if not link_elem:
                    continue
                    
                title = link_elem.get_text(strip=True)
                url = link_elem.get('href', '')
                
                if not title or not url:
                    continue
                    
                # 修复URL
                if url.startswith('//'):
                    url = 'https:' + url
                    
                # 查找摘要
                snippet = ""
                snippet_elem = result.find('div', class_='c-abstract')
                if snippet_elem:
                    snippet = snippet_elem.get_text(strip=True)
                else:
                    # 尝试其他摘要类名
                    for cls in ['c-content', 'c-span-last', 'content-right_8Zs40']:
                        elem = result.find('div', class_=cls)
                        if elem:
                            snippet = elem.get_text(strip=True)
                            break
                
                if title and url and url.startswith('http'):
                    results.append({
                        "title": title,
                        "url": url,
                        "snippet": snippet
                    })
            except Exception as e:
                print(f"解析结果时出错: {e}", file=sys.stderr)
                continue
        
        # ==========================================
        # 策略2: 查找所有带标题的链接
        # ==========================================
        if len(results) < 3:
            print(f"策略2: 查找更多结果 (当前: {len(results)})...", file=sys.stderr)
            
            for heading in soup.find_all(['h1', 'h2', 'h3', 'h4']):
                link = heading.find('a')
                if link:
                    title = link.get_text(strip=True)
                    url = link.get('href', '')
                    if title and url and len(title) > 5:
                        if url.startswith('//'):
                            url = 'https:' + url
                        if url.startswith('http'):
                            # 检查是否已存在
                            exists = any(r['url'] == url for r in results)
                            if not exists:
                                results.append({
                                    "title": title,
                                    "url": url,
                                    "snippet": ""
                                })
        
        # ==========================================
        # 策略3: 查找知识图谱/快速回答
        # ==========================================
        print("策略3: 查找知识图谱...", file=sys.stderr)
        
        # 查找百度百科/快速回答
        for cls in ['c-span18', 'opr-result-top', 'c-border']:
            kg_elem = soup.find('div', class_=cls)
            if kg_elem:
                kg_title = kg_elem.find('h2') or kg_elem.find('h3')
                if kg_title:
                    title_text = kg_title.get_text(strip=True)
                    if title_text and len(title_text) > 2:
                        kg_snippet = kg_elem.get_text(strip=True)[:500]
                        results.insert(0, {
                            "title": f"📌 {title_text}",
                            "url": search_url,
                            "snippet": kg_snippet,
                            "is_knowledge": True
                        })
                        break
        
        # ==========================================
        # 去重和过滤
        # ==========================================
        seen_urls = set()
        unique_results = []
        for r in results:
            url = r.get('url', '')
            if url and url not in seen_urls:
                # 过滤掉百度内部链接（除了知识图谱）
                if r.get('is_knowledge') or ('baidu.com' not in url) or ('link.baidu.com' in url):
                    seen_urls.add(url)
                    # 移除内部标记
                    r.pop('is_knowledge', None)
                    unique_results.append(r)
        
        print(f"最终结果: {len(unique_results)} 个", file=sys.stderr)
        
        # 如果还是没有结果，返回备用方案
        if not unique_results:
            return [{
                "title": "💡 使用浏览器搜索",
                "url": "https://www.bing.com",
                "snippet": "建议使用 ClawX 的 browser 工具进行搜索，更加稳定可靠。",
                "alternative": "browser"
            }]
        
        return unique_results[:max_results]
        
    except Exception as e:
        print(f"错误: {e}", file=sys.stderr)
        import traceback
        traceback.print_exc()
        return [{
            "error": str(e),
            "suggestion": "使用 browser 工具进行搜索"
        }]

def print_results_formatted(results):
    """格式化输出结果"""
    if not results:
        print("未找到搜索结果")
        return
        
    for i, result in enumerate(results, 1):
        if 'error' in result:
            print(f"❌ {result['error']}")
            if 'suggestion' in result:
                print(f"💡 {result['suggestion']}")
            continue
            
        print(f"\n{i}. {result.get('title', '无标题')}")
        if result.get('url'):
            print(f"   🔗 {result['url']}")
        if result.get('snippet'):
            snippet = result['snippet'][:200] + ('...' if len(result['snippet']) > 200 else '')
            print(f"   📝 {snippet}")

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print(json.dumps({"error": "Please provide a search query"}))
        sys.exit(1)
    
    query = " ".join(sys.argv[1:])
    results = search_baidu(query)
    
    # 检查是否需要格式化输出
    if '--format' in sys.argv or '-f' in sys.argv:
        print_results_formatted(results)
    else:
        print(json.dumps(results, ensure_ascii=False))

```



---

## Skill Companion Files

> Additional files collected from the skill directory layout.

### README.md

```markdown
# 🔍 Unified Search - 统一智能搜索！

> 中文用百度，英文用 DuckDuckGo，加密货币用 CoinGecko —— 一个技能，搞定所有搜索！

---

## 🚀 这是什么？

这是 OpenClaw 的**统一智能搜索神器**，自动识别查询类型，调用最合适的搜索引擎！

**小白直接用，零门槛！** 说句话就搞定，剩下的交给它！

---

## ✨ 为什么你一定要装？

### 🎯 三种智能搜索模式，总有一款适合你

| 方式 | 特点 | 推荐度 |
|------|------|--------|
| **统一智能搜索** | 自动语言检测 + 智能选择引擎 | ⭐⭐⭐⭐⭐⭐ 首选首选！ |
| **智能 Python 脚本** | 百度 + Bing + CoinGecko 三保险 | ⭐⭐⭐⭐ 备选 |
| **Playwright 浏览器搜索** | 最稳定、能处理验证码 | ⭐⭐⭐⭐ 备选 |

### 💪 强大功能
- ✅ **中文自动用百度** - 中文搜索最懂
- ✅ **英文自动用 DuckDuckGo** - 隐私保护 + 英文内容
- ✅ **加密货币自动用 CoinGecko** - 实时价格，精准可靠
- ✅ **自动 Fallback** - 百度失败用 DDG，DDG 失败用百度
- ✅ **张嘴就来** - 自然语言触发，零技术门槛
- ✅ **结构化结果** - 标题、链接、摘要，一目了然
- ✅ **来源标记** - 清楚知道结果来自哪个引擎

---

## 🎯 怎么用？（首选方式，零门槛！）

### ✨ 方式1：统一智能搜索（最推荐！⭐⭐⭐⭐⭐⭐）

自动识别查询语言，智能选择搜索引擎！

```bash
# 进入技能目录
cd skills/baidu-search

# 中文查询 → 自动用百度
python scripts/unified_search.py "Python 教程" --format

# 英文查询 → 自动用 DuckDuckGo
python scripts/unified_search.py "Python tutorial" --format

# 加密货币 → 自动用 CoinGecko
python scripts/unified_search.py "btc价格" --format
python scripts/unified_search.py "ETH 价格" --format
```

**一个脚本，搞定所有搜索！** 🚀

---

### 🧠 方式2：智能 Python 脚本（推荐！⭐⭐⭐⭐）

百度 + Bing + CoinGecko 三保险，还能自动识别加密货币！

```bash
# 进入技能目录
cd skills/baidu-search

# 普通搜索
python scripts/smart_search.py "Python 教程" --format

# 加密货币搜索（自动识别！）
python scripts/smart_search.py "btc价格" --format
python scripts/smart_search.py "ETH 价格" --format
```

---

### 🌐 方式3：Playwright 浏览器搜索（最稳定！⭐⭐⭐⭐）

使用 ClawX 内置的 browser 工具，稳定可靠：

```javascript
// 1. 启动浏览器
browser(action="start")

// 2. 打开百度
browser(action="open", targetUrl="https://www.baidu.com")

// 3. 获取页面快照
browser(action="snapshot")

// 4. 在搜索框输入关键词（找到搜索框的 ref）
browser(action="act", request={
  kind: "type",
  ref: "e5",  // 替换为实际的 ref
  text: "Python 教程"
})

// 5. 按回车搜索
browser(action="act", request={
  kind: "press",
  ref: "e5",
  key: "Enter"
})

// 6. 获取搜索结果
browser(action="snapshot")
```

---

### 💬 方式4：直接说（最简单！）

你只管张嘴说，剩下的交给它：

- "搜索 Python 教程"
- "查一下 BTC 最新价格"
- "用百度搜今天的新闻"
- "帮我找 Python tutorial"
- "ETH 现在多少钱？"

---

## 📋 能搜什么？（什么都能搜！）

| 搜索类型 | 示例 | 自动选择的引擎 |
|---------|------|---------------|
| **中文技术教程** | "搜索 Python 异步编程" | 百度 |
| **英文资料** | "查 Python tutorial" | DuckDuckGo |
| **中文新闻** | "用百度查今天的新闻" | 百度 |
| **BTC 价格** | "BTC 最新价格" | CoinGecko |
| **ETH 价格** | "ETH 现在多少钱" | CoinGecko |
| **问题解答** | "如何安装 Docker" | 百度 |
| **学习资料** | "机器学习入门教程" | 百度 |
| **行业动态** | "最近的科技新闻" | 百度 |
| **生活常识** | "怎么做番茄炒蛋" | 百度 |
| **天气查询** | "今天的天气" | 百度 |

---

## 🧠 智能检测逻辑

### 语言自动检测
```python
# 中文 → 百度
"Python 教程" → 百度 ✓
"今天天气怎么样" → 百度 ✓

# 英文 → DuckDuckGo
"Python tutorial" → DuckDuckGo ✓
"How to learn AI" → DuckDuckGo ✓
```

### 加密货币自动检测
```python
# 加密货币关键词 → CoinGecko
"btc价格" → CoinGecko ✓
"BTC 价格" → CoinGecko ✓
"ETH 价格" → CoinGecko ✓
"eth价格" → CoinGecko ✓
```

### 自动 Fallback
```
百度失败 → 自动尝试 DuckDuckGo
DuckDuckGo 失败 → 自动尝试百度
都失败 → 建议使用浏览器搜索
```

---

## 💡 最佳实践

### 推荐工作流

1. **首先尝试**：统一智能搜索 `unified_search.py`（最方便）
2. **备选方案**：智能 Python 脚本 `smart_search.py`（三保险）
3. **备选方案**：Playwright 浏览器搜索（最稳定）
4. **如果都失败**：提示用户直接访问对应搜索引擎

### 搜索技巧

1. **具体关键词** - 搜索词越具体，结果越精准
2. **组合关键词** - 使用多个相关关键词组合搜索
3. **引号精确匹配** - 用引号括起来进行精确短语匹配
4. **高级搜索语法** - 使用 `site:`, `filetype:` 等高级语法

---

## 🔧 文件说明

```
skills/baidu-search/
├── SKILL.md                    # 技能文档（必看！）
├── README.md                   # 本文件
├── package.json                # 技能配置
├── requirements.txt            # Python 依赖
├── OPTIMIZATION_SUMMARY.md     # 优化总结
├── scripts/
│   ├── unified_search.py       # ✨ 统一智能搜索（首选！）
│   ├── smart_search.py         # 🧠 智能搜索脚本（备选）
│   └── baidu_search.py         # 🔍 原始百度搜索脚本
├── example_usage.js            # 使用示例
└── quick_test.py               # 快速测试脚本
```

---

## ⚠️ 注意事项

### 统一智能搜索
- ✅ 自动语言检测，无需手动选择
- ✅ 自动 Fallback，确保搜索成功率
- ✅ 加密货币自动识别，实时价格
- **推荐作为首选方式** ⭐

### 智能 Python 脚本
- ✅ 百度 + Bing 双保险
- ✅ CoinGecko 实时加密货币价格
- ✅ 自动 Fallback 机制
- 推荐作为备选方式

### Playwright 浏览器搜索
- 需要手动操作几步
- 但更稳定、更可靠
- 可以处理验证码等复杂情况
- 推荐在脚本搜索失败时使用

---

## 🛠️ 故障排除

### 问题1：百度搜索遇到验证码
**解决**：改用 Playwright 浏览器搜索方式

### 问题2：找不到搜索框元素
**解决**：重新执行 `browser(action="snapshot")` 获取最新的页面状态和元素引用

### 问题3：搜索结果不完整
**解决**：
- 使用 `browser(action="act", request={ kind: "wait", timeMs: 3000 })` 等待页面完全加载
- 尝试滚动页面查看更多结果

### 问题4：语言检测不准确
**解决**：可以手动选择搜索引擎，或使用更明确的关键词

---

## 🌐 相关链接

- **百度官网** - https://www.baidu.com/
- **DuckDuckGo** - https://duckduckgo.com/
- **CoinGecko** - https://www.coingecko.com/
- **OpenClaw 官网** - https://openclaw.ai/

---

## 📝 更新日志

### v2.0 (2026-03-03) ✨ 统一智能搜索大升级！
- 🎉 **新增统一智能搜索** - 自动语言检测 + 智能引擎选择
- 🇨🇳 中文自动用百度
- 🇺🇸 英文自动用 DuckDuckGo
- 💰 加密货币自动用 CoinGecko
- 🔄 自动 Fallback 机制
- 📊 搜索结果标明来源
- ⭐ **现在首选 unified_search.py！**

### v1.5 (2026-03-03) 🧠 智能搜索升级！
- ✨ 新增智能搜索脚本（smart_search.py）
- 🤖 自动识别加密货币查询
- 💰 集成 CoinGecko API 获取实时价格
- 🔄 百度 → Bing → 浏览器的 Fallback 机制
- 📝 完善文档和示例

### v1.0 (2026-03-03) 🌐 浏览器搜索大升级！
- ✨ 新增 Playwright 浏览器搜索方式（推荐）
- 🔧 优化 Python 脚本，改进解析策略
- 📝 更新文档，提供更详细的使用说明
- 💡 添加使用示例和最佳实践

### v0.1
- 🎉 初始版本发布
- ✅ 支持 Python 脚本搜索

---

## 🎯 总结一下

**这个技能能帮你：**
- ✅ 一个脚本搞定所有搜索！
- ✅ 中文自动用百度，英文自动用 DuckDuckGo
- ✅ 加密货币自动用 CoinGecko 实时价格
- ✅ 自动 Fallback，确保搜索成功率
- ✅ 多种搜索方式，灵活选择

**首选方式：统一智能搜索 unified_search.py ⭐⭐⭐⭐⭐⭐**

---

**一个技能，搞定所有搜索！** 🔍

```

### _meta.json

```json
{
  "owner": "coder-knock",
  "slug": "unified-search",
  "displayName": "Unified Search - 统一智能搜索",
  "latest": {
    "version": "2.0.0",
    "publishedAt": 1772525913102,
    "commit": "https://github.com/openclaw/skills/commit/ef7acc86b66ec60909c34b35b0c4c800ca94badb"
  },
  "history": []
}

```