chore: 删除根目录下的临时测试文件

移除根目录下的测试脚本：
- test_clean_json.py
- test_hybrid_case.py
- test_model_cache.py
- test_relation_analyzer.py

这些是临时测试文件，不再需要保留在代码库中

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

test_clean_json.py

@@ -1,56 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""测试增强的JSON解析器"""
-
-import sys
-from pathlib import Path
-
-# 添加项目根目录到路径
-project_root = Path(__file__).parent
-sys.path.insert(0, str(project_root))
-
-from lib.batch_match_analyzer import clean_json_text, parse_batch_match_response
-
-# 模拟Pro模型的错误输出（包含trib{）
-error_json = '''```json
-[
-  {
-    "特征": "健忘",
-    "分数": 0.00,
-    "说明": "测试1"
-  },
-trib{
-    "特征": "抗压能力",
-    "分数": 0.00,
-    "说明": "测试2"
-  },
-  {
-    "特征": "公司最底层",
-    "分数": 0.00,
-    "说明": "测试3"
-  }
-]
-```'''
-
-print('=' * 70)
-print('测试增强的JSON解析器')
-print('=' * 70)
-
-print('\n原始JSON（包含错误trib{）:')
-print(error_json[:150] + '...')
-
-print('\n清理后的JSON:')
-cleaned = clean_json_text(error_json)
-print(cleaned[:150] + '...')
-
-print('\n尝试解析...')
-result = parse_batch_match_response(error_json)
-print(f'解析结果数量: {len(result)}')
-
-if len(result) > 1:
-    print('✅ 成功解析！')
-    for i, r in enumerate(result):
-        print(f"  {i+1}. {r.get('特征')}: {r.get('分数')}")
-else:
-    print('❌ 解析失败')
-    print(f"返回: {result}")

test_hybrid_case.py

@@ -1,34 +0,0 @@
-#!/usr/bin/env python3
-"""
-测试混合相似度计算：拟人 vs 形式
-"""
-
-import asyncio
-from lib.hybrid_similarity import compare_phrases
-
-
-async def main():
-    print("=" * 80)
-    print("测试案例：拟人 vs 形式")
-    print("=" * 80)
-    print()
-
-    # 测试混合相似度
-    result = await compare_phrases(
-        phrase_a="拟人",
-        phrase_b="形式",
-        weight_embedding=0.5,
-        weight_semantic=0.5
-    )
-
-    print(f"相似度: {result['相似度']:.3f}")
-    print()
-    print("说明:")
-    print("-" * 80)
-    print(result['说明'])
-    print()
-    print("=" * 80)
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

test_model_cache.py

@@ -1,53 +0,0 @@
-#!/usr/bin/env python3
-"""
-测试模型缓存机制
-"""
-from lib.text_embedding import compare_phrases
-
-print("=" * 60)
-print("测试模型缓存机制")
-print("=" * 60)
-print()
-
-# 第一次调用 - 会加载模型
-print("第一次调用 compare_phrases（会加载模型）:")
-result1 = compare_phrases("深度学习", "神经网络")
-print(f"相似度: {result1['相似度']:.3f}")
-print()
-
-# 第二次调用 - 不会加载模型（使用缓存）
-print("第二次调用 compare_phrases（使用缓存，不会重新加载）:")
-result2 = compare_phrases("机器学习", "人工智能")
-print(f"相似度: {result2['相似度']:.3f}")
-print()
-
-# 第三次调用 - 不会加载模型（使用缓存）
-print("第三次调用 compare_phrases（使用缓存，不会重新加载）:")
-result3 = compare_phrases("Python", "Java")
-print(f"相似度: {result3['相似度']:.3f}")
-print()
-
-# 切换到多语言模型 - 第一次会加载
-print("切换到多语言模型（第一次会加载）:")
-result4 = compare_phrases("Hello", "Hi", model_name="multilingual")
-print(f"相似度: {result4['相似度']:.3f}")
-print()
-
-# 再次使用多语言模型 - 不会加载（使用缓存）
-print("再次使用多语言模型（使用缓存，不会重新加载）:")
-result5 = compare_phrases("Good", "Great", model_name="multilingual")
-print(f"相似度: {result5['相似度']:.3f}")
-print()
-
-# 切换回中文模型 - 不会加载（之前已加载）
-print("切换回中文模型（使用缓存，不会重新加载）:")
-result6 = compare_phrases("编程", "开发")
-print(f"相似度: {result6['相似度']:.3f}")
-print()
-
-print("=" * 60)
-print("总结:")
-print("  - 每个模型只在第一次使用时加载一次")
-print("  - 后续调用直接使用缓存的模型")
-print("  - 可以自由切换不同模型，已加载的模型会保留在内存中")
-print("=" * 60)

test_relation_analyzer.py

@@ -1,209 +0,0 @@
-"""
-测试 relation_analyzer 模块
-"""
-import asyncio
-from lib.relation_analyzer import analyze_relation
-
-
-async def test_all_relations():
-    """测试所有7种关系类型"""
-
-    # 测试用例：每种关系类型的典型例子
-    test_cases = [
-        # 1. same（同义）
-        {
-            "phrase_a": "医生",
-            "phrase_b": "大夫",
-            "expected_relation": "same",
-            "description": "完全同义"
-        },
-        {
-            "phrase_a": "计算机",
-            "phrase_b": "电脑",
-            "expected_relation": "same",
-            "description": "完全同义"
-        },
-
-        # 2. coordinate（同级）
-        {
-            "phrase_a": "轿车",
-            "phrase_b": "SUV",
-            "expected_relation": "coordinate",
-            "description": "都是汽车的子类"
-        },
-        {
-            "phrase_a": "苹果",
-            "phrase_b": "香蕉",
-            "expected_relation": "coordinate",
-            "description": "都是水果"
-        },
-
-        # 3. contains（包含）
-        {
-            "phrase_a": "水果",
-            "phrase_b": "苹果",
-            "expected_relation": "contains",
-            "description": "水果包含苹果"
-        },
-        {
-            "phrase_a": "汽车",
-            "phrase_b": "轿车",
-            "expected_relation": "contains",
-            "description": "汽车包含轿车"
-        },
-
-        # 4. contained_by（被包含）
-        {
-            "phrase_a": "苹果",
-            "phrase_b": "水果",
-            "expected_relation": "contained_by",
-            "description": "苹果被水果包含"
-        },
-        {
-            "phrase_a": "轿车",
-            "phrase_b": "交通工具",
-            "expected_relation": "contained_by",
-            "description": "轿车被交通工具包含"
-        },
-
-        # 5. overlap（部分重叠）
-        {
-            "phrase_a": "红苹果",
-            "phrase_b": "大苹果",
-            "expected_relation": "overlap",
-            "description": "有交集（又红又大的苹果）"
-        },
-        {
-            "phrase_a": "学生",
-            "phrase_b": "运动员",
-            "expected_relation": "overlap",
-            "description": "有交集（学生运动员）"
-        },
-
-        # 6. related（相关）
-        {
-            "phrase_a": "医生",
-            "phrase_b": "医院",
-            "expected_relation": "related",
-            "description": "工作场所关系"
-        },
-        {
-            "phrase_a": "阅读",
-            "phrase_b": "书籍",
-            "expected_relation": "related",
-            "description": "动作-对象关系"
-        },
-
-        # 7. unrelated（无关）
-        {
-            "phrase_a": "医生",
-            "phrase_b": "石头",
-            "expected_relation": "unrelated",
-            "description": "完全无关"
-        },
-        {
-            "phrase_a": "苹果",
-            "phrase_b": "数学",
-            "expected_relation": "unrelated",
-            "description": "完全无关"
-        },
-    ]
-
-    # 模型选择（根据你的配置调整）
-    model_name = "google/gemini-2.5-flash"  # 默认模型
-
-    print(f"=" * 80)
-    print(f"开始测试 relation_analyzer 模块")
-    print(f"使用模型: {model_name}")
-    print(f"测试用例数量: {len(test_cases)}")
-    print(f"=" * 80)
-    print()
-
-    results = []
-
-    for i, test_case in enumerate(test_cases, 1):
-        phrase_a = test_case["phrase_a"]
-        phrase_b = test_case["phrase_b"]
-        expected = test_case["expected_relation"]
-        description = test_case["description"]
-
-        print(f"[{i}/{len(test_cases)}] 测试: \"{phrase_a}\" <-> \"{phrase_b}\"")
-        print(f"     说明: {description}")
-        print(f"     期望关系: {expected}")
-
-        # 调用分析函数
-        result = await analyze_relation(
-            phrase_a=phrase_a,
-            phrase_b=phrase_b,
-            model_name=model_name
-        )
-
-        relation = result.get("relation", "unknown")
-        score = result.get("score", 0.0)
-        explanation = result.get("explanation", "")
-
-        # 判断是否符合预期
-        is_correct = (relation == expected)
-        status = "✓" if is_correct else "✗"
-
-        print(f"     实际关系: {relation} (score: {score:.2f}) {status}")
-        print(f"     解释: {explanation}")
-        print()
-
-        results.append({
-            "test_case": test_case,
-            "result": result,
-            "is_correct": is_correct
-        })
-
-    # 统计结果
-    correct_count = sum(1 for r in results if r["is_correct"])
-    total_count = len(results)
-    accuracy = correct_count / total_count * 100
-
-    print(f"=" * 80)
-    print(f"测试完成")
-    print(f"正确: {correct_count}/{total_count} ({accuracy:.1f}%)")
-    print(f"=" * 80)
-
-    # 显示错误的测试用例
-    errors = [r for r in results if not r["is_correct"]]
-    if errors:
-        print()
-        print("错误的测试用例：")
-        for error in errors:
-            tc = error["test_case"]
-            result = error["result"]
-            print(f"  - \"{tc['phrase_a']}\" <-> \"{tc['phrase_b']}\"")
-            print(f"    期望: {tc['expected_relation']}, 实际: {result['relation']}")
-
-    return results
-
-
-async def test_single_example():
-    """测试单个例子"""
-
-    print("测试单个例子：")
-    print()
-
-    result = await analyze_relation(
-        phrase_a="水果",
-        phrase_b="苹果",
-        model_name="google/gemini-2.5-flash"  # 默认模型
-    )
-
-    print(f"短语A: 水果")
-    print(f"短语B: 苹果")
-    print(f"关系: {result['relation']}")
-    print(f"分数: {result['score']}")
-    print(f"解释: {result['explanation']}")
-
-
-if __name__ == "__main__":
-    # 选择测试方式：
-
-    # 方式1：测试单个例子（快速验证）
-    # asyncio.run(test_single_example())
-
-    # 方式2：测试所有关系类型（完整测试）
-    asyncio.run(test_all_relations())