Skill: zhouchang1988/skill-to-cn (version 1.0.0)

--- name: skill-to-cn description: 将任意技能汉化为中文版本。当用户要求"汉化技能"、"翻译技能"、"把XX技能翻译成中文"、"创建技能的中文版"时触发。输入原始技能路径（如 ~/.claude/skills/X/），输出汉化后的技能目录（~/.claude/skills/X-cn/）。 --- # 技能汉化器 将任意 Claude Code 技能翻译为中文版本。 ## 核心职责 **重要**：本技能的完整工作流程包含两个阶段： 1. **脚本阶段**：运行翻译脚本，生成标记 `[待翻译]` 的骨架文件 2. **模型阶段**：Claude 必须读取骨架文件，完成所有 `[待翻译]` 内容的实际翻译 最终输出的必须是**已完成翻译的中文技能**，而非标记状态的中间产物。 ## 工作流程 汉化技能涉及以下步骤： 1. 确认源技能路径（默认 ~/.claude/skills/<技能名>/） 2. 读取并分析源技能结构 3. 运行翻译脚本，生成目标目录骨架 4. **Claude 读取并翻译所有标记内容** 5. 输出完整翻译后的技能文件 6. 验证汉化结果 ## 执行汉化 ### 第一步：运行脚本生成骨架 运行汉化脚本生成带标记的骨架文件： ```bash python3 ~/.claude/skills/skill-to-cn/scripts/translate_skill.py <源技能名> ``` 示例： ```bash # 汉化 pdf-editor 技能 python3 ~/.claude/skills/skill-to-cn/scripts/translate_skill.py pdf-editor # 指定完整路径 python3 ~/.claude/skills/skill-to-cn/scripts/translate_skill.py /path/to/skill --output /custom/output ``` 脚本会创建目标目录并标记所有需要翻译的内容。 ### 第二步：Claude 完成翻译 **这是关键步骤，必须由 Claude 执行：** 1. 读取生成的目标目录中的所有文件 2. 找到所有 `[待翻译]` 标记的内容 3. 将标记内容翻译为中文，并**移除 `[待翻译]` 标记** 4. 将翻译后的内容写回文件 翻译时遵循以下原则： - 保留代码块、命令、文件路径不翻译 - 保留 Markdown 格式标记 - 技术术语可保留英文或使用通用译名 - 专有名词（API 名称、库名、命令名等）保持原文 - 确保翻译后的内容流畅自然 **产出物语言设定**：在汉化过程中，需要在 SKILL.md 中明确指定输出语言为中文（除非原文另有要求）。这确保汉化后的技能执行时，其产出物默认使用中文： - 文档和说明使用中文 - 代码注释使用中文 - 程序输出和提示信息使用中文 - 专有名词保持原文 ### 第三步：验证输出 确认所有文件已完成翻译，无残留的 `[待翻译]` 标记。 ## 手动汉化指南 如需手动汉化，遵循以下规则： ### YAML 元数据翻译 ```yaml # 原文 --- name: pdf-editor description: Professional PDF editing toolkit for merging, splitting, and rotating PDFs. Use when user asks to "merge PDFs", "split PDF", or "rotate PDF". --- # 译文 --- name: pdf-editor-cn description: 专业 PDF 编辑工具包，支持合并、拆分和旋转 PDF。当用户要求"合并 PDF"、"拆分 PDF"、"旋转 PDF"时使用。 --- ``` ### 正文翻译原则 1. **保留代码块**：代码示例和命令不翻译 2. **保留文件路径**：路径、URL、技术术语保持原样 3. **翻译描述性文本**：说明、指导、步骤描述等 4. **保留格式标记**：Markdown 语法不变 5. **技术术语处理**： - 常见术语保留英文或使用通用译名 - 首次出现可标注英文原文 6. **专有名词保留**：文档中的专有名词（如 API 名称、库名、命令名等）保持原文不翻译 ### 产出物语言要求 **核心原则**：汉化后的技能执行时，其产出物应以中文为默认语言。 具体规则如下： | 场景 | 处理方式 | |------|---------| | 原文未指定语言 | 产出物使用中文 | | 原文要求英文输出 | 保持英文（尊重原文要求） | | 原文要求其他语言 | 保持该语言（尊重原文要求） | | 文档中的专有名词 | 保持原文不翻译 | | 代码注释 | 翻译为中文 | | 代码输出/提示信息 | 翻译为中文 | | 代码变量名/函数名 | 保持原文 | **实施方法**：在汉化 SKILL.md 时，应在技能说明中添加以下内容（如适用）： ```markdown ## 输出语言 本技能的输出内容默认使用中文。除非用户明确要求其他语言，否则： - 文档和说明使用中文 - 代码注释使用中文 - 程序输出和提示信息使用中文 - 专有名词（API 名称、库名等）保持原文 ``` ### 文件处理 | 文件类型 | 处理方式 | |---------|---------| | SKILL.md | 翻译元数据和正文，添加"输出语言"说明（指定中文为默认） | | README.md | 翻译为 README-cn.md（仅当目标目录不存在 README-cn.md 时） | | scripts/* (任意语言) | 翻译注释和输出内容为中文，保留代码逻辑和变量名 | | scripts/* (二进制文件) | 直接复制，不翻译 | | references/*.md | 翻译全部内容，专有名词保持原文 | | references/* (二进制文件) | 直接复制，不翻译 | | assets/* | 直接复制（图片、模板等） | | 根目录其他文件 | 直接复制（如 LICENSE.txt 等） | ### 二进制文件检测 脚本会自动检测以下类型的二进制文件并直接复制： - **图片**：.png, .jpg, .gif, .ico, .webp, .svg 等 - **音频**：.mp3, .wav, .ogg, .flac 等 - **视频**：.mp4, .avi, .mkv, .mov 等 - **压缩包**：.zip, .tar, .gz, .rar, .7z 等 - **可执行文件**：.exe, .dll, .so, .dylib 等 - **字体**：.ttf, .otf, .woff, .woff2 等 - **PDF 和文档**：.pdf, .doc, .docx, .xls, .xlsx 等 - **其他**：.bin, .dat, .pyc, .jar 等 此外，脚本还会通过检测文件内容中的空字节（\x00）来识别未知的二进制文件格式。 ### 支持的代码语言 脚本文件支持以下语言的注释翻译： | 注释风格 | 支持的语言 | |---------|-----------| | `#` 单行注释 | Python, Shell, Ruby, YAML, TOML, R, Perl 等 | | `//` 和 `/* */` | JavaScript, TypeScript, Java, C, C++, Go, Rust, Swift, Kotlin, Scala, C#, PHP 等 | | `<!-- -->` | HTML, XML, Vue, Svelte 等 | | `/* */` | CSS, SCSS, LESS 等 | ## 输出结构 汉化后的技能目录： ``` ~/.claude/skills/<技能名>-cn/ ├── SKILL.md # 已翻译 ├── README-cn.md # README.md 的中文翻译（如源目录存在 README.md） ├── scripts/ # 注释已翻译 ├── references/ # 已翻译（如存在） ├── assets/ # 原样复制（如存在） └── <其他文件> # 原样复制（如 LICENSE.txt） ``` ## 完整汉化示例 假设用户要求汉化 `pdf-editor` 技能： **用户**：请汉化 pdf-editor 技能 **Claude 执行流程**： ``` 1. 运行脚本： python3 ~/.claude/skills/skill-to-cn/scripts/translate_skill.py pdf-editor 2. 脚本输出骨架文件，内容类似： --- name: pdf-editor-cn description: [待翻译] Professional PDF editing toolkit... --- [待翻译] # PDF Editor [待翻译] A professional toolkit for PDF operations. 3. Claude 读取骨架文件，翻译并写入最终内容： --- name: pdf-editor-cn description: 专业 PDF 编辑工具包，支持合并、拆分和旋转 PDF... --- # PDF 编辑器 专业 PDF 操作工具包。 4. 确认所有文件已翻译完成，无 [待翻译] 残留 ``` **最终输出**：完整可用的中文版技能，用户可直接使用。

path: README.md
content: # skill-to-cn

将任意 Claude Code 技能翻译为中文版本。

## 用途

当用户要求"汉化技能"、"翻译技能"、"把XX技能翻译成中文"、"创建技能的中文版"时使用此技能。

## 安装

将此技能目录放置在 Claude Code 的 skills 目录下：

```bash
# 克隆到 Claude Code skills 目录
git clone https://github.com/zhouchang1988/skill-to-cn.git ~/.claude/skills/skill-to-cn
```

## 使用方法

在 Claude Code 中请求汉化技能：

```
请汉化 pdf-editor 技能
```

或者指定完整路径：

```
请将 /path/to/skill 翻译成中文
```

## 工作流程

1. 确认源技能路径
2. 运行翻译脚本生成骨架文件
3. Claude 完成所有标记内容的翻译
4. 验证汉化结果

## 输出结构

汉化后的技能目录位于 `~/.claude/skills/<技能名>-cn/`：

```
~/.claude/skills/<技能名>-cn/
├── SKILL.md          # 已翻译
├── README-cn.md      # README.md 的中文翻译（如存在）
├── scripts/          # 注释已翻译
├── references/       # 已翻译（如存在）
├── assets/           # 原样复制（如存在）
└── <其他文件>        # 原样复制
```

## 许可证

MIT License


path: scripts/translate_skill.py
content: #!/usr/bin/env python3
"""
技能汉化脚本
将 Claude Code 技能翻译为中文版本
"""

import argparse
import os
import re
import shutil
import sys
from pathlib import Path


def is_binary_file(file_path: Path) -> bool:
    """检测文件是否为二进制文件"""
    # 常见二进制文件扩展名
    binary_extensions = {
        # 图片
        '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.webp', '.svg', '.tiff', '.tif',
        # 音频
        '.mp3', '.wav', '.ogg', '.flac', '.aac', '.m4a', '.wma',
        # 视频
        '.mp4', '.avi', '.mkv', '.mov', '.wmv', '.flv', '.webm',
        # 压缩包
        '.zip', '.tar', '.gz', '.rar', '.7z', '.bz2', '.xz',
        # 可执行文件
        '.exe', '.dll', '.so', '.dylib', '.app', '.dmg', '.deb', '.rpm',
        # 数据库
        '.db', '.sqlite', '.sqlite3',
        # 字体
        '.ttf', '.otf', '.woff', '.woff2', '.eot',
        # PDF 和文档
        '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx',
        # 其他二进制
        '.bin', '.dat', '.iso', '.img', '.class', '.jar', '.war', '.pyc', '.pyo',
    }

    ext = file_path.suffix.lower()
    if ext in binary_extensions:
        return True

    # 通过文件内容检测：尝试读取前 8192 字节，检查是否包含空字节
    try:
        with open(file_path, 'rb') as f:
            chunk = f.read(8192)
            if b'\x00' in chunk:
                return True
    except (IOError, OSError):
        pass

    return False


def parse_args():
    parser = argparse.ArgumentParser(
        description="将 Claude Code 技能汉化为中文版本",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
示例:
  %(prog)s pdf-editor
  %(prog)s /path/to/skill --output /custom/output
  %(prog)s my-skill --no-translate
        """
    )
    parser.add_argument(
        "skill",
        help="源技能名称或完整路径"
    )
    parser.add_argument(
        "--output", "-o",
        help="输出目录路径（默认：~/.claude/skills/<技能名>-cn/）"
    )
    parser.add_argument(
        "--no-translate",
        action="store_true",
        help="仅复制结构，不执行翻译（用于手动翻译）"
    )
    return parser.parse_args()


def get_skill_paths(skill_name: str, output_override: str = None) -> tuple:
    """获取源技能路径和目标路径"""
    skills_dir = Path.home() / ".claude" / "skills"

    # 判断是完整路径还是技能名
    if "/" in skill_name or skill_name.startswith("~"):
        source_path = Path(skill_name).expanduser().resolve()
    else:
        source_path = skills_dir / skill_name

    # 验证源路径存在
    if not source_path.exists():
        print(f"❌ 错误：技能目录不存在: {source_path}")
        sys.exit(1)

    # 确定目标路径
    if output_override:
        target_path = Path(output_override).expanduser().resolve()
    else:
        skill_dir_name = source_path.name
        if skill_dir_name.endswith("-cn"):
            print(f"❌ 错误：源技能已是中文版本: {skill_dir_name}")
            sys.exit(1)
        target_path = source_path.parent / f"{skill_dir_name}-cn"

    return source_path, target_path


def translate_yaml_metadata(content: str) -> str:
    """翻译 SKILL.md 的 YAML 前置元数据"""
    # 匹配 YAML 前置元数据
    yaml_pattern = r'^---\s*\n(.*?)\n---\s*\n'
    match = re.match(yaml_pattern, content, re.DOTALL)

    if not match:
        return content

    yaml_content = match.group(1)

    # 解析 YAML 字段
    lines = yaml_content.split('\n')
    translated_lines = []

    for line in lines:
        if line.startswith('name:'):
            # 添加 -cn 后缀
            name = line.split(':', 1)[1].strip()
            if not name.endswith('-cn'):
                name = f"{name}-cn"
            translated_lines.append(f"name: {name}")
        elif line.startswith('description:'):
            # 标记需要翻译
            desc = line.split(':', 1)[1].strip()
            translated_lines.append(f"description: [待翻译] {desc}")
        else:
            translated_lines.append(line)

    # 重建内容
    translated_yaml = '---\n' + '\n'.join(translated_lines) + '\n---\n'
    return translated_yaml + content[match.end():]


def translate_python_comments(content: str) -> str:
    """翻译 Python 文件中的注释和文档字符串"""
    lines = content.split('\n')
    translated_lines = []

    in_docstring = False
    docstring_char = None

    for line in lines:
        # 检测文档字符串开始/结束
        stripped = line.strip()

        if not in_docstring:
            # 跳过 shebang 行
            if stripped.startswith('#!'):
                translated_lines.append(line)
            # 检查是否开始文档字符串
            elif stripped.startswith('"""') or stripped.startswith("'''"):
                docstring_char = stripped[:3]
                if stripped.count(docstring_char) >= 2:
                    # 单行文档字符串
                    translated_lines.append(f"# [待翻译] {line}")
                else:
                    in_docstring = True
                    translated_lines.append(f"# [待翻译] {line}")
            elif stripped.startswith('#'):
                # 普通注释
                translated_lines.append(f"# [待翻译] {line}")
            else:
                translated_lines.append(line)
        else:
            translated_lines.append(f"# [待翻译] {line}")
            if docstring_char in stripped:
                in_docstring = False

    return '\n'.join(translated_lines)


# 定义各语言的注释规则
COMMENT_RULES = {
    # 单行注释符号 -> 是否支持多行注释
    'hash': {  # # 风格：Python, Shell, Ruby, YAML, TOML, etc.
        'single': '#',
        'multi_start': None,
        'multi_end': None,
    },
    'double_slash': {  # // 风格：JavaScript, TypeScript, Java, C, C++, Go, Rust, etc.
        'single': '//',
        'multi_start': '/*',
        'multi_end': '*/',
    },
    'html': {  # HTML, XML
        'single': None,
        'multi_start': '<!--',
        'multi_end': '-->',
    },
    'css': {  # CSS, SCSS, LESS
        'single': None,
        'multi_start': '/*',
        'multi_end': '*/',
    },
}

# 文件扩展名到注释规则的映射
EXT_TO_RULE = {
    # Hash 风格
    '.py': 'hash',
    '.sh': 'hash',
    '.bash': 'hash',
    '.zsh': 'hash',
    '.rb': 'hash',
    '.yaml': 'hash',
    '.yml': 'hash',
    '.toml': 'hash',
    '.r': 'hash',
    '.R': 'hash',
    '.perl': 'hash',
    '.pl': 'hash',
    '.pm': 'hash',
    # Double slash 风格
    '.js': 'double_slash',
    '.jsx': 'double_slash',
    '.ts': 'double_slash',
    '.tsx': 'double_slash',
    '.java': 'double_slash',
    '.c': 'double_slash',
    '.cpp': 'double_slash',
    '.cc': 'double_slash',
    '.cxx': 'double_slash',
    '.h': 'double_slash',
    '.hpp': 'double_slash',
    '.go': 'double_slash',
    '.rs': 'double_slash',
    '.swift': 'double_slash',
    '.kt': 'double_slash',
    '.kts': 'double_slash',
    '.scala': 'double_slash',
    '.cs': 'double_slash',
    '.php': 'double_slash',  # PHP 也支持 //
    # HTML 风格
    '.html': 'html',
    '.htm': 'html',
    '.xml': 'html',
    '.vue': 'html',  # Vue 文件中 HTML 部分用 HTML 注释
    '.svelte': 'html',
    # CSS 风格
    '.css': 'css',
    '.scss': 'css',
    '.less': 'css',
}


def translate_generic_code_comments(content: str, rule_name: str) -> str:
    """翻译通用代码文件中的注释"""
    rule = COMMENT_RULES.get(rule_name)
    if not rule:
        return content

    lines = content.split('\n')
    translated_lines = []
    in_multi_comment = False

    single_char = rule.get('single')
    multi_start = rule.get('multi_start')
    multi_end = rule.get('multi_end')

    for line in lines:
        stripped = line.strip()

        if in_multi_comment:
            # 在多行注释中
            translated_lines.append(f"{single_char or '//'} [待翻译] {line}")
            if multi_end and multi_end in stripped:
                in_multi_comment = False
        elif stripped.startswith('#!'):
            # 跳过 shebang 行
            translated_lines.append(line)
        elif multi_start and stripped.startswith(multi_start):
            # 多行注释开始
            if multi_end in stripped and stripped.find(multi_end) > stripped.find(multi_start):
                # 单行内的多行注释
                translated_lines.append(f"{single_char or '//'} [待翻译] {line}")
            else:
                in_multi_comment = True
                translated_lines.append(f"{single_char or '//'} [待翻译] {line}")
        elif single_char and stripped.startswith(single_char):
            # 单行注释
            translated_lines.append(f"{single_char} [待翻译] {line}")
        else:
            translated_lines.append(line)

    return '\n'.join(translated_lines)


def translate_code_file(source_file: Path, target_file: Path, translate: bool = True):
    """处理任意代码文件，翻译注释和输出内容"""
    # 检测是否为二进制文件
    if is_binary_file(source_file):
        shutil.copy2(source_file, target_file)
        print(f"  📦 已复制（二进制）: scripts/{source_file.name}")
        return

    content = source_file.read_text(encoding='utf-8')

    if translate:
        ext = source_file.suffix.lower()
        rule_name = EXT_TO_RULE.get(ext)

        if ext == '.py':
            # Python 有特殊的文档字符串处理
            content = translate_python_comments(content)
        elif rule_name:
            # 使用通用注释翻译
            content = translate_generic_code_comments(content, rule_name)
        else:
            # 未知类型，原样复制
            pass

    target_file.write_text(content, encoding='utf-8')
    # 保留原始文件权限（如可执行权限）
    shutil.copymode(source_file, target_file)
    print(f"  📝 {'已翻译' if translate else '已复制'}: scripts/{source_file.name}")


def translate_markdown(content: str) -> str:
    """翻译 Markdown 文件内容（标记待翻译）"""
    lines = content.split('\n')
    translated_lines = []
    in_code_block = False
    in_yaml_front_matter = False
    yaml_count = 0

    for i, line in enumerate(lines):
        stripped = line.strip()

        # 检测 YAML 前置元数据（已由 translate_yaml_metadata 处理，跳过）
        if stripped == '---':
            yaml_count += 1
            if yaml_count == 1:
                in_yaml_front_matter = True
            elif yaml_count == 2:
                in_yaml_front_matter = False
            translated_lines.append(line)
            continue

        if in_yaml_front_matter:
            translated_lines.append(line)
            continue

        # 检测代码块
        if stripped.startswith('```'):
            in_code_block = not in_code_block
            translated_lines.append(line)
        elif in_code_block:
            # 代码块内容不翻译
            translated_lines.append(line)
        elif not stripped:
            # 空行保留
            translated_lines.append(line)
        elif stripped.startswith('- ✅') or stripped.startswith('- **') or stripped.startswith('| '):
            # 列表项、表格行：标记待翻译
            translated_lines.append(f"[待翻译] {line}")
        elif stripped.startswith('#'):
            # Markdown 标题
            translated_lines.append(f"[待翻译] {line}")
        elif stripped.startswith('- ') or stripped.startswith('* ') or re.match(r'^\d+\.', stripped):
            # 无序/有序列表
            translated_lines.append(f"[待翻译] {line}")
        elif stripped.startswith('![') or stripped.startswith('['):
            # 链接或图片引用，保留
            translated_lines.append(line)
        else:
            # 普通描述性文本
            translated_lines.append(f"[待翻译] {line}")

    return '\n'.join(translated_lines)


def process_readme_file(source_file: Path, target_file: Path, translate: bool = True):
    """处理 README.md 文件，翻译为 README-cn.md"""
    content = source_file.read_text(encoding='utf-8')

    if translate:
        content = translate_markdown(content)

    target_file.write_text(content, encoding='utf-8')
    print(f"  📝 {'已翻译' if translate else '已复制'}: README.md → README-cn.md")


def process_skill_md(source_file: Path, target_file: Path, translate: bool = True):
    """处理 SKILL.md 文件"""
    content = source_file.read_text(encoding='utf-8')

    if translate:
        content = translate_yaml_metadata(content)
        content = translate_markdown(content)

    target_file.write_text(content, encoding='utf-8')
    print(f"  📝 {'已翻译' if translate else '已复制'}: SKILL.md")


def process_reference_file(source_file: Path, target_file: Path, translate: bool = True):
    """处理参考文档"""
    # 检测是否为二进制文件
    if is_binary_file(source_file):
        shutil.copy2(source_file, target_file)
        print(f"  📦 已复制（二进制）: references/{source_file.name}")
        return

    content = source_file.read_text(encoding='utf-8')

    if translate and source_file.suffix == '.md':
        content = translate_markdown(content)

    target_file.write_text(content, encoding='utf-8')
    print(f"  📝 {'已翻译' if translate else '已复制'}: references/{source_file.name}")


def copy_asset(source_file: Path, target_file: Path):
    """复制资产文件"""
    shutil.copy2(source_file, target_file)
    file_type = "二进制" if is_binary_file(source_file) else "文件"
    print(f"  📦 已复制（{file_type}）: assets/{source_file.name}")


def translate_skill(source_path: Path, target_path: Path, translate: bool = True):
    """执行技能汉化"""
    print(f"\n{'='*50}")
    print(f"🔧 技能汉化工具")
    print(f"{'='*50}")
    print(f"📂 源路径: {source_path}")
    print(f"📂 目标路径: {target_path}")
    print(f"🌐 翻译模式: {'开启' if translate else '关闭（仅复制）'}")
    print(f"{'='*50}\n")

    # 创建目标目录
    if target_path.exists():
        print(f"⚠️  目标目录已存在，将被覆盖")
        shutil.rmtree(target_path)

    target_path.mkdir(parents=True)

    # 处理 SKILL.md
    skill_md = source_path / "SKILL.md"
    if skill_md.exists():
        process_skill_md(skill_md, target_path / "SKILL.md", translate)
    else:
        print(f"⚠️  未找到 SKILL.md")

    # 处理 scripts/
    scripts_dir = source_path / "scripts"
    if scripts_dir.exists():
        target_scripts = target_path / "scripts"
        target_scripts.mkdir()
        print(f"\n📁 处理 scripts/")
        for script_file in scripts_dir.iterdir():
            if script_file.is_file():
                # 处理所有代码文件，翻译注释和输出内容
                translate_code_file(script_file, target_scripts / script_file.name, translate)

    # 处理 references/
    refs_dir = source_path / "references"
    if refs_dir.exists():
        target_refs = target_path / "references"
        target_refs.mkdir()
        print(f"\n📁 处理 references/")
        for ref_file in refs_dir.iterdir():
            if ref_file.is_file():
                process_reference_file(ref_file, target_refs / ref_file.name, translate)

    # 处理 assets/
    assets_dir = source_path / "assets"
    if assets_dir.exists():
        target_assets = target_path / "assets"
        target_assets.mkdir()
        print(f"\n📁 处理 assets/")
        for asset_file in assets_dir.iterdir():
            if asset_file.is_file():
                copy_asset(asset_file, target_assets / asset_file.name)
            elif asset_file.is_dir():
                shutil.copytree(asset_file, target_assets / asset_file.name)
                print(f"  📦 已复制目录: assets/{asset_file.name}")

    # 处理 README.md（翻译为 README-cn.md）
    readme_md = source_path / "README.md"
    readme_cn = target_path / "README-cn.md"
    if readme_md.exists() and not readme_cn.exists():
        process_readme_file(readme_md, readme_cn, translate)
    else:
        # 处理根目录中的其他文件（SKILL.md、README.md 以外的文件，如 LICENSE.txt 等）
        known_dirs = {'scripts', 'references', 'assets'}
        root_files = [
            f for f in source_path.iterdir()
            if f.is_file() and f.name not in ('SKILL.md', 'README.md')
        ]
        if root_files:
            print(f"\n📁 处理根目录其他文件")
            for root_file in root_files:
                shutil.copy2(root_file, target_path / root_file.name)
                print(f"  📦 已复制: {root_file.name}")

    print(f"\n{'='*50}")
    print(f"✅ 汉化完成！")
    print(f"{'='*50}")
    print(f"\n后续步骤:")
    print(f"1. 检查目标目录: {target_path}")
    if translate:
        print(f"2. 编辑 SKILL.md 完成标记为 [待翻译] 的内容")
        print(f"3. 检查并完善翻译质量")
    print()


def main():
    args = parse_args()
    source_path, target_path = get_skill_paths(args.skill, args.output)
    translate_skill(source_path, target_path, translate=not args.no_translate)


if __name__ == "__main__":
    main()


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