Skill: lj22503/lj22503-skill-optimizer (version 1.0.1)

--- name: skill-optimizer version: 1.0.1 description: ［何时使用］当用户需要评估技能质量时；当用户说"检查这个 skill"时；当创建或修改 skill 后需要验证时；当检测到"skill 优化""skill 评估""技能检查"等关键词时；当批量检查多个技能时 author: 燃冰 + 小蚂蚁 created: 2026-03-20 skill_type: 通用🟡 allowed-tools: [Bash, Read, Write, Exec] related_skills: [skill-creator, skill-vetter] tags: [skill 优化，技能评估，标准检查，质量保证，自动化] --- # 技能优化师 🔍 **基于 SKILL-STANDARD-v3.md** --- ## 📋 功能描述 自动评估技能文件是否符合 SKILL-STANDARD-v3.md 规范，提供优化建议。 **适用场景：** - 新技能创建后检查 - 技能修改后验证 - 批量技能质量评估 - 标准合规性检查 **边界条件：** - 不自动修改技能文件（需用户确认） - 基于最新标准（SKILL-STANDARD-v3.md） - 提供建议而非强制执行 --- ## 🎯 核心功能 ### 功能 1：元数据检查 **检查项**： - [ ] name 字段（必填，唯一标识） - [ ] version 字段（可选，语义化版本） - [ ] description 字段（必填，触发说明式） - [ ] allowed-tools 字段（推荐，限制工具） - [ ] skill_type 字段（选填，核心/通用/实验） - [ ] author 字段（选填） - [ ] created 字段（选填） - [ ] related_skills 字段（可选） - [ ] tags 字段（可选） **触发词验证**： - description 是否包含 `［何时使用］` - 是否包含具体触发场景 - 是否包含关键词检测 --- ### 功能 2：正文结构检查 **轻量级模板检查**（适用于 80% 技能）： - [ ] 技能名称标题（# 技能名称） - [ ] 功能描述章节 - [ ] 适用场景列表 - [ ] 边界条件说明 - [ ] 常见错误章节 - [ ] 使用示例章节 - [ ] 相关资源链接 - [ ] 故障排查章节 **完整级模板检查**（复杂技能）： - [ ] 核心功能详解 - [ ] 渐进式披露结构 - [ ] references 目录 - [ ] 外部资源链接 --- ### 功能 2.5：模板文件校验（MANDATORY） **检查技能中提到的所有模板/参考文件是否实际存在：** **校验规则**： 1. 提取 SKILL.md 中提到的所有模板文件（`templates/xxx.md`） 2. 检查文件是否实际存在于 skill 文件夹中 3. 如果提到但不存在 → **直接不通过** **检查项**： - [ ] 提取所有 `templates/` 目录引用 - [ ] 验证文件实际存在 - [ ] 检查 templates 目录是否为空（如果提到） **🚨 不通过标准**： ``` ───────────────────────────────────────── • SKILL.md 中提到 templates/xxx.md 但文件不存在 • SKILL.md 中提到 references/xxx.md 但文件不存在 • SKILL.md 中提到 scripts/xxx.py 但文件不存在 • templates/目录被提到但为空 ───────────────────────────────────────── ``` **校验脚本**： ```bash #!/bin/bash # 模板文件校验脚本 SKILL_DIR=$1 MISSING_FILES=() # 提取所有提到的文件 for pattern in "templates/[\w-]+\.md" "references/[\w-]+\.md" "scripts/[\w-]+\.py"; do while IFS= read -r file; do if [ ! -f "$SKILL_DIR/$file" ]; then MISSING_FILES+=("$file") fi done < <(grep -oP "$pattern" "$SKILL_DIR/SKILL.md") done # 输出结果 if [ ${#MISSING_FILES[@]} -gt 0 ]; then echo "❌ 缺少文件：" for f in "${MISSING_FILES[@]}"; do echo " - $f" done exit 1 else echo "✅ 所有提到的文件都存在" exit 0 fi ``` **评分影响**： - 模板文件缺失 → **直接判定为不合格（<60 分）** - 模板文件完整 → 质量评分 +10 分 --- ### 功能 3：质量评分 **评分维度**： | 维度 | 权重 | 检查项 | |------|------|--------| | 元数据完整 | 20% | 必填字段、格式规范 | | 触发清晰度 | 25% | description 质量、关键词覆盖 | | 结构完整 | 25% | 必需章节、渐进披露 | | 内容质量 | 20% | 示例、错误、故障排查 | | 规范性 | 10% | 命名、格式、链接 | **模板文件校验（一票否决）**： - 模板文件完整 → 质量评分 +10 分 - 模板文件缺失 → **直接判定为不合格（<60 分）** **评级标准**： - ≥90 分：优秀（符合标准） - ≥75 分：良好（少量优化） - ≥60 分：合格（需要优化） - <60 分：需改进（大量问题） - **模板文件缺失 → 直接不通过** --- ### 功能 4：优化建议生成 **建议类型**： 1. **必须修复**（影响触发或使用） 2. **建议优化**（提升质量） 3. **可选改进**（锦上添花） **建议格式**： ```markdown ### 🔴 必须修复 **问题**：description 缺少触发词 **当前**：`description: 身份认同习惯` **建议**：`description: ［何时使用］当用户想培养习惯时；当用户说"我想成为 XX"时` **原因**：没有触发词，技能无法被正确触发 ``` --- ## ⚠️ 常见错误 **错误 1：description 过于简略** ``` 问题： • 只写功能名称，没有触发场景 • 缺少关键词检测 解决： ✓ 使用［何时使用］格式 ✓ 列出具体触发场景 ✓ 包含关键词检测 ``` **错误 2：缺少 allowed-tools** ``` 问题： • 未限制可用工具 • 可能存在安全隐患 解决： ✓ 明确指定 allowed-tools ✓ 遵循最小权限原则 ``` **错误 3：缺少故障排查** ``` 问题： • 用户遇到问题无法解决 • 增加支持成本 解决： ✓ 添加故障排查章节 ✓ 列出常见问题和解决方案 ``` **错误 4：文件过长无渐进披露** ``` 问题： • SKILL.md 超过 300 行 • 启动时加载过多内容 解决： ✓ 创建 references 目录 ✓ 主文件保持 100-150 行 ✓ 使用链接引用外部资源 ``` **错误 5：模板文件缺失** ``` 问题： • SKILL.md 中提到 templates/xxx.md 但文件不存在 • 提到参考文件但没有实际创建 解决： ✓ 创建所有提到的模板文件 ✓ 或者删除对不存在文件的引用 ✓ 使用模板校验脚本检查 ``` --- ## 🧪 使用示例 **输入**： ```bash # 检查单个技能 python3 skill-optimizer/scripts/optimize-skill.py value-analyzer # 批量检查 python3 skill-optimizer/scripts/optimize-skill.py --batch investment-framework-skill # 检查并生成报告 python3 skill-optimizer/scripts/optimize-skill.py stock-picker --report ``` **预期输出**： ``` 🔍 技能优化师：stock-picker ================================================== 📊 元数据检查 ✅ name: stock-picker ✅ version: 2.0.0 ✅ description: ［何时使用］当用户需要选股时... ⚠️ allowed-tools: 缺失 📋 正文结构检查 ✅ 功能描述 ✅ 常见错误 ⚠️ 故障排查：缺失 📈 质量评分 总分：78/100（良好） 💡 优化建议 🔴 必须修复：补充 allowed-tools 🟡 建议优化：添加故障排查章节 ``` --- ## 🔗 相关资源 - `references/checklist.md` - 完整检查清单 - `references/examples.md` - 评估示例 - `references/scoring.md` - 评分标准详解 - `scripts/optimize-skill.py` - 评估脚本 --- ## 🔧 故障排查 | 问题 | 检查项 | 解决方案 | |------|--------|---------| | 不触发 | description 是否包含触发词？ | 将关键词加入 description | | 评分异常 | 标准文件存在吗？ | 检查 SKILL-STANDARD-v3.md | | 脚本报错 | 有执行权限吗？ | `chmod +x scripts/*.py` | | 批量失败 | 目录路径正确吗？ | 使用绝对路径 | | 模板文件缺失 | SKILL.md 中提到的文件存在吗？ | 创建缺失的模板文件或删除引用 | --- *基于 SKILL-STANDARD-v3.md* *最后更新：2026-03-20*

path: references/checklist.md
content: # 技能评估检查清单

**基于 SKILL-STANDARD-v3.md**

---

## 元数据检查（50 分）

### 必填字段（30 分）- v3.0 标准只要求 2 个

- [ ] **name** - 技能名称（唯一标识）
- [ ] **description** - 触发说明（1024 字符内，包含［何时使用］）

### 推荐字段（20 分）

- [ ] **version** - 语义化版本（如 1.0.0）
- [ ] **allowed-tools** - 限制可用工具
- [ ] **author** - 作者
- [ ] **created** - 创建日期
- [ ] **skill_type** - 技能类型（核心🔴/通用🟡/实验🟢）
- [ ] **related_skills** - 相关技能列表
- [ ] **tags** - 搜索标签

---

## 正文结构检查（50 分）

### 必需章节（30 分）- v3.0 轻量级模板

- [ ] **## 📋 功能描述** - 帮助用户达成什么目标
- [ ] **## ⚠️ 常见错误** - 错误和解决方案

### 推荐章节（20 分）

- [ ] **## 🧪 使用示例** - 输入输出示例
- [ ] **## 🔗 相关资源** - 外部资源链接
- [ ] **## 🔧 故障排查** - 问题和解决方案表格

---

## 渐进式披露（20 分）

- [ ] 文件长度 < 200 行
- [ ] 或创建 references 目录
- [ ] 主文件包含 references 链接

---

## 评分标准（v3.0）

| 分数 | 评级 | 说明 |
|------|------|------|
| ≥90 | 优秀 🌟 | 符合标准，无需优化 |
| ≥75 | 良好 ✅ | 少量优化 |
| ≥60 | 合格 ⚠️ | 需要优化 |
| <60 | 需改进 ❌ | 大量问题 |

**注意**：v3.0 标准强调简约高效，不强制所有字段。

---

*最后更新：2026-03-20*


path: scripts/check-templates.py
content: #!/usr/bin/env python3
"""
技能模板文件校验器
检查技能中提到的所有模板/参考文件是否实际存在
"""

import os
import re
import sys
from pathlib import Path

class Colors:
    GREEN = '\033[92m'
    RED = '\033[91m'
    YELLOW = '\033[93m'
    BLUE = '\033[94m'
    RESET = '\033[0m'
    BOLD = '\033[1m'

def check_skill_templates(skill_dir):
    """检查单个技能的模板文件"""
    skill_md = os.path.join(skill_dir, 'SKILL.md')
    
    if not os.path.exists(skill_md):
        return {'status': '❌ FAIL', 'missing': ['SKILL.md 不存在'], 'mentioned': []}
    
    with open(skill_md, 'r', encoding='utf-8') as f:
        content = f.read()
    
    # 提取提到的文件
    mentioned_files = set()
    
    # 匹配 templates/xxx.md 格式
    patterns = [
        r'templates/[\w-]+\.md',
        r'references/[\w-]+\.md',
        r'scripts/[\w-]+\.py',
    ]
    
    for pattern in patterns:
        matches = re.findall(pattern, content)
        mentioned_files.update(matches)
    
    # 检查文件是否存在
    missing = []
    found = []
    
    for file_path in mentioned_files:
        full_path = os.path.join(skill_dir, file_path)
        if os.path.exists(full_path):
            found.append(file_path)
        else:
            missing.append(file_path)
    
    if missing:
        return {
            'status': '❌ FAIL',
            'missing': missing,
            'found': found,
            'mentioned': list(mentioned_files)
        }
    else:
        return {
            'status': '✅ PASS',
            'missing': [],
            'found': found,
            'mentioned': list(mentioned_files)
        }

def check_all_skills(skills_root):
    """检查所有技能"""
    results = []
    
    for root, dirs, files in os.walk(skills_root):
        if 'SKILL.md' in files:
            result = check_skill_templates(root)
            skill_name = os.path.basename(root)
            results.append({
                'skill': skill_name,
                'path': root,
                'result': result
            })
    
    return results

def main():
    if len(sys.argv) > 1:
        # 检查单个技能
        skill_dir = sys.argv[1]
        result = check_skill_templates(skill_dir)
        skill_name = os.path.basename(skill_dir)
        
        print(f"{Colors.BOLD}╔══════════════════════════════════════════════════════════╗{Colors.RESET}")
        print(f"{Colors.BOLD}║   技能模板文件校验 - {skill_name:<40}║{Colors.RESET}")
        print(f"{Colors.BOLD}╚══════════════════════════════════════════════════════════╝{Colors.RESET}\n")
        
        print(f"状态：{result['status']}")
        print(f"\n提到的文件 ({len(result['mentioned'])}个):")
        for f in result['mentioned']:
            if f in result['found']:
                print(f"  {Colors.GREEN}✅{Colors.RESET} {f}")
            else:
                print(f"  {Colors.RED}❌{Colors.RESET} {f} (缺失)")
        
        if result['missing']:
            print(f"\n{Colors.RED}❌ 缺少 {len(result['missing'])} 个文件：{Colors.RESET}")
            for f in result['missing']:
                print(f"  - {f}")
            print(f"\n{Colors.RED}❌ 校验不通过！请先创建缺失的模板文件。{Colors.RESET}")
            print(f"{Colors.YELLOW}⚠️  根据技能优化器标准，模板文件缺失直接判定为不合格（<60 分）{Colors.RESET}")
            sys.exit(1)
        else:
            print(f"\n{Colors.GREEN}✅ 所有提到的文件都存在，校验通过！{Colors.RESET}")
            sys.exit(0)
    
    else:
        # 检查所有技能
        skills_root = '/home/admin/.openclaw/workspace/betterlife/skills'
        results = check_all_skills(skills_root)
        
        print(f"{Colors.BOLD}╔══════════════════════════════════════════════════════════╗{Colors.RESET}")
        print(f"{Colors.BOLD}║   BetterLife 技能模板文件批量校验                        ║{Colors.RESET}")
        print(f"{Colors.BOLD}╚══════════════════════════════════════════════════════════╝{Colors.RESET}\n")
        
        passed = 0
        failed = 0
        total_files = 0
        missing_files = 0
        
        failed_skills = []
        
        for r in results:
            if r['result']['status'] == '✅ PASS':
                passed += 1
                total_files += len(r['result']['found'])
            else:
                failed += 1
                missing_files += len(r['result']['missing'])
                failed_skills.append(r)
        
        print(f"{Colors.GREEN}✅ 通过：{passed} 个技能{Colors.RESET}")
        print(f"{Colors.RED}❌ 失败：{failed} 个技能{Colors.RESET}")
        print(f"\n总文件数：{total_files} 个")
        print(f"缺失文件：{missing_files} 个\n")
        
        if failed_skills:
            print(f"{Colors.BOLD}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━{Colors.RESET}")
            print(f"{Colors.RED}失败的技能 ({failed}个):{Colors.RESET}\n")
            
            for r in failed_skills:
                print(f"{Colors.YELLOW}{r['skill']}{Colors.RESET}")
                print(f"  路径：{r['path']}")
                print(f"  缺失文件:")
                for f in r['result']['missing']:
                    print(f"    - {f}")
                print()
            
            print(f"{Colors.RED}❌ 校验不通过！请先创建缺失的模板文件。{Colors.RESET}")
            print(f"{Colors.YELLOW}⚠️  根据技能优化器标准，模板文件缺失直接判定为不合格（<60 分）{Colors.RESET}")
            sys.exit(1)
        else:
            print(f"{Colors.GREEN}✅ 所有技能的模板文件校验通过！{Colors.RESET}")
            sys.exit(0)

if __name__ == '__main__':
    main()


path: scripts/optimize-skill.py
content: #!/usr/bin/env python3
"""
技能优化师 - 自动评估技能是否符合 SKILL-STANDARD-v3.md

用法:
    python3 optimize-skill.py <skill_name> [--batch <dir>] [--report]
"""

import os
import re
import sys
import json
from datetime import datetime

# 配置
SKILLS_DIRS = [
    os.path.expanduser('~/.openclaw/workspace/skills'),
    os.path.expanduser('~/.openclaw/workspace/investment-framework-skill'),
    os.path.expanduser('~/.openclaw/workspace/investment-framework-skill/china-masters'),
]
STANDARD_FILE = os.path.expanduser('~/.openclaw/workspace/docs/SKILL-STANDARD-v3.md')

# 必填元数据字段（v3.0 标准：只要求 2 个）
REQUIRED_FIELDS = ['name', 'description']
RECOMMENDED_FIELDS = ['version', 'allowed-tools', 'author', 'created', 'skill_type', 'related_skills', 'tags']

# 必需章节（v3.0 轻量级模板）
REQUIRED_SECTIONS = [
    '## 📋 功能描述',
    '## ⚠️ 常见错误',
]

# 推荐章节
RECOMMENDED_SECTIONS = [
    '## 🧪 使用示例',
    '## 🔗 相关资源',
    '## 🔧 故障排查',
]


def load_standard():
    """加载标准文件"""
    if os.path.exists(STANDARD_FILE):
        with open(STANDARD_FILE, 'r', encoding='utf-8') as f:
            return f.read()
    return None


def parse_skill_metadata(content):
    """解析技能元数据"""
    metadata = {}
    
    # 提取 YAML frontmatter
    match = re.search(r'^---\n(.*?)\n---', content, re.DOTALL)
    if match:
        yaml_content = match.group(1)
        for line in yaml_content.split('\n'):
            if ':' in line:
                key, value = line.split(':', 1)
                metadata[key.strip()] = value.strip().strip('"\'')
    
    return metadata


def check_metadata(metadata):
    """检查元数据"""
    results = {
        'required': {},
        'recommended': {},
        'issues': [],
    }
    
    # 检查必填字段
    for field in REQUIRED_FIELDS:
        if field in metadata and metadata[field]:
            results['required'][field] = {'status': '✅', 'value': metadata[field]}
        else:
            results['required'][field] = {'status': '❌', 'value': '缺失'}
            results['issues'].append(f'🔴 必填字段缺失：{field}')
    
    # 检查推荐字段
    for field in RECOMMENDED_FIELDS:
        if field in metadata and metadata[field]:
            results['recommended'][field] = {'status': '✅', 'value': metadata[field]}
        else:
            results['recommended'][field] = {'status': '⚠️', 'value': '缺失'}
    
    # 特殊检查：description 触发词
    if 'description' in metadata:
        desc = metadata['description']
        if '［何时使用］' not in desc and '[何时使用]' not in desc:
            results['issues'].append('🔴 description 缺少触发词［何时使用］')
        elif len(desc) > 1024:
            results['issues'].append('🟡 description 超过 1024 字符')
    
    # 特殊检查：skill_type 规范（如果有）
    if 'skill_type' in metadata:
        skill_type = metadata['skill_type']
        valid_types = ['核心🔴', '通用🟡', '实验🟢', '核心', '通用', '实验']
        if skill_type not in valid_types:
            results['issues'].append(f'🟡 skill_type 不规范：{skill_type}')
    else:
        # skill_type 是推荐字段，不强制
        pass
    
    return results


def check_structure(content):
    """检查正文结构"""
    results = {
        'required': {},
        'recommended': {},
        'issues': [],
    }
    
    # 检查必需章节
    for section in REQUIRED_SECTIONS:
        if section in content:
            results['required'][section] = {'status': '✅'}
        else:
            results['required'][section] = {'status': '❌'}
            results['issues'].append(f'🔴 缺少必需章节：{section}')
    
    # 检查推荐章节
    for section in RECOMMENDED_SECTIONS:
        if section in content:
            results['recommended'][section] = {'status': '✅'}
        else:
            results['recommended'][section] = {'status': '⚠️'}
    
    # 检查渐进式披露
    if 'references/' in content or '`references/' in content:
        results['progressive'] = {'status': '✅', 'note': '已实现渐进式披露'}
    else:
        # 检查文件长度
        lines = content.split('\n')
        if len(lines) > 200:
            results['progressive'] = {'status': '⚠️', 'note': f'文件过长 ({len(lines)}行)，建议渐进式披露'}
            results['issues'].append('🟡 文件过长，建议创建 references 目录')
        else:
            results['progressive'] = {'status': '✅', 'note': '文件长度合理'}
    
    return results


def calculate_score(metadata_results, structure_results):
    """计算质量评分（v3.0 标准）"""
    score = 0
    max_score = 100
    
    # 元数据评分（50 分）
    # 必填字段 30 分，推荐字段 20 分
    required_count = len([v for v in metadata_results['required'].values() if v['status'] == '✅'])
    required_total = len(metadata_results['required'])
    metadata_score = (required_count / required_total * 30) if required_total > 0 else 0
    
    recommended_count = len([v for v in metadata_results['recommended'].values() if v['status'] == '✅'])
    recommended_total = len(metadata_results['recommended'])
    metadata_score += (recommended_count / recommended_total * 20) if recommended_total > 0 else 0
    
    score += min(metadata_score, 50)
    
    # 结构评分（50 分）
    # 必需章节 30 分，推荐章节 20 分
    required_sections = len([v for v in structure_results['required'].values() if v['status'] == '✅'])
    required_total = len(structure_results['required'])
    structure_score = (required_sections / required_total * 30) if required_total > 0 else 0
    
    recommended_sections = len([v for v in structure_results['recommended'].values() if v['status'] == '✅'])
    recommended_total = len(structure_results['recommended'])
    structure_score += (recommended_sections / recommended_total * 20) if recommended_total > 0 else 0
    
    score += min(structure_score, 50)
    
    # 不扣分，只给建议
    # v3.0 标准：简约高效，不惩罚
    
    return max(0, min(100, score))


def get_rating(score):
    """获取评级"""
    if score >= 90:
        return '优秀', '🌟'
    elif score >= 75:
        return '良好', '✅'
    elif score >= 60:
        return '合格', '⚠️'
    else:
        return '需改进', '❌'


def generate_suggestions(metadata_results, structure_results):
    """生成优化建议"""
    suggestions = {
        'critical': [],  # 必须修复
        'recommended': [],  # 建议优化
        'optional': [],  # 可选改进
    }
    
    # 元数据问题
    for field, result in metadata_results['required'].items():
        if result['status'] == '❌':
            suggestions['critical'].append(f'补充必填字段：{field}')
    
    # description 触发词
    if any('缺少触发词' in issue for issue in metadata_results['issues']):
        suggestions['critical'].append('description 添加［何时使用］触发词')
    
    # 结构问题
    for section, result in structure_results['required'].items():
        if result['status'] == '❌':
            suggestions['critical'].append(f'添加必需章节：{section}')
    
    # 推荐字段
    for field, result in metadata_results['recommended'].items():
        if result['status'] == '⚠️' and field == 'allowed-tools':
            suggestions['recommended'].append(f'补充推荐字段：{field}')
    
    # 渐进式披露
    if structure_results.get('progressive', {}).get('status') == '⚠️':
        suggestions['recommended'].append('创建 references 目录，实现渐进式披露')
    
    return suggestions


def find_skill_file(skill_name):
    """查找技能文件"""
    for skills_dir in SKILLS_DIRS:
        # 直接查找
        skill_file = os.path.join(skills_dir, skill_name, 'SKILL.md')
        if os.path.exists(skill_file):
            return skill_file
        
        # 在子目录查找（如 china-masters）
        for root, dirs, files in os.walk(skills_dir):
            if 'SKILL.md' in files:
                dir_name = os.path.basename(root)
                if dir_name == skill_name or f'/{skill_name}/' in root:
                    return os.path.join(root, 'SKILL.md')
    
    return None


def optimize_skill(skill_name):
    """优化单个技能"""
    skill_file = find_skill_file(skill_name)
    
    if not skill_file:
        return {'error': f'技能文件不存在：{skill_name}'}
    
    # 读取技能文件
    with open(skill_file, 'r', encoding='utf-8') as f:
        content = f.read()
    
    # 解析元数据
    metadata = parse_skill_metadata(content)
    
    # 检查元数据
    metadata_results = check_metadata(metadata)
    
    # 检查结构
    structure_results = check_structure(content)
    
    # 计算评分
    score = calculate_score(metadata_results, structure_results)
    rating, rating_icon = get_rating(score)
    
    # 生成建议
    suggestions = generate_suggestions(metadata_results, structure_results)
    
    return {
        'skill_name': skill_name,
        'timestamp': datetime.now().isoformat(),
        'metadata': metadata_results,
        'structure': structure_results,
        'score': score,
        'rating': rating,
        'rating_icon': rating_icon,
        'suggestions': suggestions,
    }


def print_report(result):
    """打印评估报告"""
    if 'error' in result:
        print(f"❌ 错误：{result['error']}")
        return
    
    print("="*60)
    print(f"🔍 技能优化师：{result['skill_name']}")
    print("="*60)
    print(f"\n📊 评估时间：{result['timestamp']}")
    
    # 元数据检查
    print(f"\n📋 元数据检查")
    for field, check in result['metadata']['required'].items():
        print(f"   {check['status']} {field}: {check['value'][:50] if len(str(check['value'])) > 50 else check['value']}")
    
    print(f"\n   推荐字段:")
    for field, check in result['metadata']['recommended'].items():
        print(f"     {check['status']} {field}: {check['value']}")
    
    # 正文结构检查
    print(f"\n📑 正文结构检查")
    print(f"   必需章节:")
    for section, check in result['structure']['required'].items():
        print(f"     {check['status']} {section}")
    
    print(f"   推荐章节:")
    for section, check in result['structure']['recommended'].items():
        print(f"     {check['status']} {section}")
    
    print(f"   渐进式披露：{result['structure'].get('progressive', {}).get('note', 'N/A')}")
    
    # 质量评分
    print(f"\n📈 质量评分")
    print(f"   总分：{result['score']}/100 {result['rating_icon']}（{result['rating']}）")
    
    # 优化建议
    print(f"\n💡 优化建议")
    if result['suggestions']['critical']:
        print(f"\n   🔴 必须修复：")
        for suggestion in result['suggestions']['critical']:
            print(f"     • {suggestion}")
    
    if result['suggestions']['recommended']:
        print(f"\n   🟡 建议优化：")
        for suggestion in result['suggestions']['recommended']:
            print(f"     • {suggestion}")
    
    if result['suggestions']['optional']:
        print(f"\n   🟢 可选改进：")
        for suggestion in result['suggestions']['optional']:
            print(f"     • {suggestion}")
    
    if not any(result['suggestions'].values()):
        print(f"   ✅ 无需优化，符合标准！")
    
    print(f"\n{'='*60}")


def main():
    """主函数"""
    if len(sys.argv) < 2:
        print("用法：python3 optimize-skill.py <skill_name> [--batch <dir>] [--report]")
        print("示例：python3 optimize-skill.py value-analyzer")
        print("       python3 optimize-skill.py --batch investment-framework-skill")
        return 1
    
    if '--batch' in sys.argv:
        # 批量检查
        batch_idx = sys.argv.index('--batch')
        if batch_idx + 1 < len(sys.argv):
            batch_dir = sys.argv[batch_idx + 1]
            # 支持绝对路径和相对路径
            if os.path.isabs(batch_dir):
                batch_path = batch_dir
            else:
                # 在多个技能目录中查找
                batch_path = None
                for skills_dir in SKILLS_DIRS:
                    test_path = os.path.join(skills_dir, batch_dir)
                    if os.path.exists(test_path):
                        batch_path = test_path
                        break
                if not batch_path:
                    print(f"错误：找不到目录 {batch_dir}")
                    return 1
            
            if os.path.exists(batch_path):
                print(f"🔍 批量检查：{batch_dir}")
                print("="*60)
                
                results = []
                for item in os.listdir(batch_path):
                    item_path = os.path.join(batch_path, item)
                    if os.path.isdir(item_path) and os.path.exists(os.path.join(item_path, 'SKILL.md')):
                        result = optimize_skill(item)
                        results.append(result)
                        print(f"\n{result['skill_name']}: {result['score']}/100 ({result['rating']})")
                
                # 汇总
                print(f"\n{'='*60}")
                print(f"📊 批量检查汇总")
                print(f"   检查技能：{len(results)} 个")
                avg_score = sum(r['score'] for r in results) / len(results) if results else 0
                print(f"   平均评分：{avg_score:.1f}/100")
                print(f"   优秀：{sum(1 for r in results if r['score'] >= 90)} 个")
                print(f"   良好：{sum(1 for r in results if 75 <= r['score'] < 90)} 个")
                print(f"   合格：{sum(1 for r in results if 60 <= r['score'] < 75)} 个")
                print(f"   需改进：{sum(1 for r in results if r['score'] < 60)} 个")
        else:
            print("错误：--batch 需要指定目录")
            return 1
    else:
        # 单个检查
        skill_name = sys.argv[1]
        result = optimize_skill(skill_name)
        print_report(result)
    
    return 0


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


Security scan verdicts — ClawScan: clean | static analysis: clean | VirusTotal: clean | SkillSpector: clean (LOW)