Prompt Meta

---
name: skill-creator
description: Hướng dẫn tạo các kỹ năng (skills) hiệu quả. Kỹ năng này nên được sử dụng khi người dùng muốn tạo một kỹ năng mới (hoặc cập nhật một kỹ năng hiện có) giúp mở rộng khả năng của Claude bằng kiến thức chuyên ngành, quy trình làm việc hoặc tích hợp công cụ.
license: Xem đầy đủ các điều khoản trong LICENSE.txt
---

# Trình Tạo Kỹ Năng (Skill Creator)

Kỹ năng này cung cấp hướng dẫn để tạo ra các kỹ năng (skills) hiệu quả.

## Giới Thiệu Về Kỹ Năng (Skills)

Kỹ năng (Skills) là các gói mô-đun độc lập, khép kín giúp mở rộng khả năng của Claude bằng cách cung cấp
kiến thức chuyên ngành, quy trình làm việc và các công cụ chuyên biệt. Hãy hình dung chúng như những "cẩm nang hội nhập" (onboarding guides) cho các lĩnh vực
hoặc tác vụ cụ thể—chúng biến đổi Claude từ một tác tử đa năng thành một tác tử chuyên gia
được trang bị tri thức quy trình mà không một mô hình đơn lẻ nào có thể tự nắm giữ trọn vẹn.

### Những Gì Kỹ Năng Cung Cấp

1. Quy trình làm việc chuyên biệt - Các thủ tục nhiều bước dành cho những lĩnh vực cụ thể
2. Tích hợp công cụ - Hướng dẫn làm việc với các định dạng tệp hoặc API cụ thể
3. Chuyên môn nghiệp vụ - Kiến thức đặc thù của công ty, lược đồ dữ liệu (schemas), logic nghiệp vụ
4. Tài nguyên đóng gói kèm - Các kịch bản (scripts), tài liệu tham khảo (references) và tài sản (assets) phục vụ các tác vụ phức tạp và lặp đi lặp lại

## Các Nguyên Tắc Cốt Lõi

### Ngắn Gọn Là Chìa Khóa

Cửa sổ ngữ cảnh (context window) là tài sản chung. Các kỹ năng phải chia sẻ cửa sổ ngữ cảnh với mọi thứ khác mà Claude cần: câu lệnh hệ thống (system prompt), lịch sử hội thoại, siêu dữ liệu của các Kỹ năng khác và yêu cầu thực tế của người dùng.

**Giả định mặc định: Bản thân Claude vốn đã rất thông minh.** Chỉ bổ sung những ngữ cảnh mà Claude chưa có sẵn. Hãy chất vấn từng mẩu thông tin: "Claude có thực sự cần lời giải thích này không?" và "Đoạn văn này có xứng đáng với chi phí token mà nó tiêu tốn không?"

Ưu tiên các ví dụ ngắn gọn hơn là những lời giải thích dài dòng.

### Thiết Lập Bậc Tự Do Phù Hợp

Điều chỉnh mức độ chi tiết tương ứng với độ nhạy cảm dễ lỗi và tính biến thiên của tác vụ:

**Bậc tự do cao (hướng dẫn dạng văn bản)**: Sử dụng khi có nhiều cách tiếp cận cùng hợp lệ, các quyết định phụ thuộc vào ngữ cảnh, hoặc các nguyên tắc kinh nghiệm (heuristics) đóng vai trò dẫn dắt.

**Bậc tự do trung bình (mã giả hoặc kịch bản có tham số)**: Sử dụng khi đã có một mẫu chuẩn được ưu tiên, chấp nhận một số biến thể nhất định, hoặc cấu hình có ảnh hưởng đến hành vi.

**Bậc tự do thấp (các kịch bản cụ thể, ít tham số)**: Sử dụng khi các thao tác rất nhạy cảm và dễ phát sinh lỗi, tính nhất quán là yếu tố sống còn, hoặc bắt buộc phải tuân thủ nghiêm ngặt một trình tự cụ thể.

Hãy hình dung Claude đang khám phá một con đường: một cây cầu hẹp bắc qua vực thẳm cần những thanh lan can bảo vệ cụ thể (bậc tự do thấp), trong khi một cánh đồng rộng mở cho phép đi theo nhiều lối khác nhau (bậc tự do cao).

### Cấu Trúc Giải Phẫu Của Một Kỹ Năng

Mỗi kỹ năng bao gồm một tệp SKILL.md bắt buộc và các tài nguyên đóng gói kèm tùy chọn:

```
skill-name/
├── SKILL.md (bắt buộc)
│   ├── Siêu dữ liệu YAML frontmatter (bắt buộc)
│   │   ├── name: (bắt buộc)
│   │   └── description: (bắt buộc)
│   └── Hướng dẫn Markdown (bắt buộc)
└── Tài Nguyên Đóng Gói Kèm (tùy chọn)
    ├── scripts/          - Mã thực thi (Python/Bash/v.v.)
    ├── references/       - Tài liệu được nạp vào ngữ cảnh khi cần thiết
    └── assets/           - Các tệp được sử dụng trong kết quả đầu ra (mẫu, biểu tượng, phông chữ, v.v.)
```

#### SKILL.md (bắt buộc)

Mọi tệp SKILL.md đều bao gồm:

- **Frontmatter** (YAML): Chứa hai trường `name` và `description`. Đây là những trường duy nhất mà Claude đọc để xác định khi nào kỹ năng được kích hoạt sử dụng, do đó việc mô tả rõ ràng và toàn diện kỹ năng này là gì cũng như khi nào nên dùng nó là cực kỳ quan trọng.
- **Phần thân - Body** (Markdown): Các hướng dẫn và chỉ dẫn để sử dụng kỹ năng. Chỉ được nạp vào SAU KHI kỹ năng đã được kích hoạt (nếu có).

#### Tài Nguyên Đóng Gói Kèm (tùy chọn)

##### Kịch bản (`scripts/`)

Mã thực thi (Python/Bash/v.v.) dành cho các tác vụ đòi hỏi độ tin cậy tất định hoặc thường xuyên phải viết đi viết lại.

- **Khi nào nên đưa vào**: Khi cùng một đoạn mã cứ phải viết lại nhiều lần hoặc khi cần độ tin cậy tất định tuyệt đối
- **Ví dụ**: `scripts/rotate_pdf.py` cho các tác vụ xoay trang PDF
- **Lợi ích**: Tiết kiệm token, kết quả tất định, có thể được thực thi mà không cần nạp mã nguồn vào cửa sổ ngữ cảnh
- **Lưu ý**: Đôi khi Claude vẫn cần đọc các kịch bản này để vá lỗi hoặc điều chỉnh cho phù hợp với môi trường cụ thể

##### Tài liệu tham khảo (`references/`)

Tài liệu hướng dẫn và tư liệu tham khảo được thiết kế để nạp vào ngữ cảnh khi cần nhằm cung cấp thông tin cho quá trình xử lý và suy luận của Claude.

- **Khi nào nên đưa vào**: Dành cho các tài liệu mà Claude cần tra cứu trong quá trình làm việc
- **Ví dụ**: `references/finance.md` cho các lược đồ tài chính, `references/mnda.md` cho mẫu thỏa thuận bảo mật (NDA) của công ty, `references/policies.md` cho các chính sách công ty, `references/api_docs.md` cho đặc tả API
- **Trường hợp sử dụng**: Lược đồ cơ sở dữ liệu, tài liệu API, kiến thức chuyên ngành, chính sách công ty, hướng dẫn quy trình chi tiết
- **Lợi ích**: Giữ cho tệp SKILL.md luôn gọn nhẹ, chỉ nạp vào khi Claude xác định là thực sự cần dùng đến
- **Thực hành tốt nhất**: Nếu tệp có dung lượng lớn (>10k từ), hãy đưa các mẫu tìm kiếm grep vào trong SKILL.md
- **Tránh trùng lặp**: Thông tin chỉ nên nằm ở SKILL.md hoặc nằm ở các tệp trong thư mục references, không lặp lại ở cả hai nơi.

##### Tài sản (`assets/`)

Các tệp không nhằm mục đích nạp vào cửa sổ ngữ cảnh, mà được sử dụng trực tiếp bên trong sản phẩm đầu ra do Claude tạo ra.

- **Khi nào nên đưa vào**: Khi kỹ năng cần các tệp sẽ được đưa vào sản phẩm đầu ra cuối cùng
- **Ví dụ**: `assets/logo.png` cho tài sản nhận diện thương hiệu, `assets/slides.pptx` cho các mẫu bài thuyết trình PowerPoint
- **Trường hợp sử dụng**: Biểu mẫu (templates), hình ảnh, biểu tượng (icons), mã khung dựng sẵn (boilerplate code), phông chữ, tài liệu mẫu

### Nguyên Tắc Thiết Kế Tiết Lộ Dần Dần (Progressive Disclosure)

Các kỹ năng sử dụng hệ thống nạp ba cấp độ để quản lý ngữ cảnh một cách hiệu quả:

1. **Siêu dữ liệu (name + description)** - Luôn thường trực trong ngữ cảnh (~100 từ)
2. **Phần thân SKILL.md** - Được nạp khi kỹ năng được kích hoạt (<5k từ)
3. **Tài nguyên đóng gói kèm** - Được nạp theo nhu cầu thực tế của Claude

Hãy giữ phần thân SKILL.md tập trung vào những nội dung cốt lõi nhất và dưới 500 dòng để giảm thiểu tình trạng phình đại ngữ cảnh.

## Quy Trình Tạo Kỹ Năng

Việc tạo kỹ năng bao gồm các bước sau:

1. Hiểu rõ kỹ năng thông qua các ví dụ cụ thể
2. Lên kế hoạch cho các nội dung kỹ năng có thể tái sử dụng (scripts, references, assets)
3. Khởi tạo kỹ năng (chạy kịch bản init_skill.py)
4. Chỉnh sửa kỹ năng (triển khai các tài nguyên và viết nội dung SKILL.md)
5. Đóng gói kỹ năng (chạy kịch bản package_skill.py)
6. Lặp lại và cải tiến dựa trên quá trình sử dụng thực tế

### Bước 3: Khởi Tạo Kỹ Năng

Khi tạo một kỹ năng mới từ đầu, hãy luôn chạy kịch bản `init_skill.py`:

```bash
scripts/init_skill.py <skill-name> --path <output-directory>
```

### Bước 4: Chỉnh Sửa Kỹ Năng

Tham khảo các tài liệu hướng dẫn hữu ích sau dựa trên nhu cầu cụ thể của kỹ năng bạn đang tạo:

- **Các quy trình nhiều bước**: Xem references/workflows.md để biết các quy trình tuần tự và logic rẽ nhánh có điều kiện
- **Các định dạng đầu ra cụ thể hoặc tiêu chuẩn chất lượng**: Xem references/output-patterns.md để biết các mẫu biểu mẫu và mẫu ví dụ

### Bước 5: Đóng Gói Kỹ Năng

```bash
scripts/package_skill.py <path/to/skill-folder>
```

Kịch bản đóng gói sẽ kiểm tra tính hợp lệ và tạo ra một tệp .skill để phân phối.
FILE:references/workflows.md
# Các Mẫu Quy Trình Làm Việc (Workflow Patterns)

## Quy Trình Tuần Tự (Sequential Workflows)

Đối với các tác vụ phức tạp, hãy chia nhỏ hoạt động thành các bước tuần tự rõ ràng. Việc cung cấp cho Claude cái nhìn tổng quan về quy trình ngay ở phần đầu của tệp SKILL.md thường mang lại hiệu quả rất tốt:

```markdown
Việc điền một biểu mẫu PDF bao gồm các bước sau:

1. Phân tích biểu mẫu (chạy analyze_form.py)
2. Tạo ánh xạ trường dữ liệu (chỉnh sửa fields.json)
3. Xác thực ánh xạ (chạy validate_fields.py)
4. Điền biểu mẫu (chạy fill_form.py)
5. Kiểm tra kết quả đầu ra (chạy verify_output.py)
```

## Quy Trình Có Điều Kiện (Conditional Workflows)

Đối với các tác vụ có logic rẽ nhánh, hãy dẫn dắt Claude đi qua các điểm ra quyết định:

```markdown
1. Xác định loại sửa đổi:
   **Tạo nội dung mới?** → Làm theo "Quy trình tạo mới" bên dưới
   **Chỉnh sửa nội dung hiện có?** → Làm theo "Quy trình chỉnh sửa" bên dưới

2. Quy trình tạo mới: [steps]
3. Quy trình chỉnh sửa: [steps]
```
FILE:references/output-patterns.md
# Các Mẫu Đầu Ra (Output Patterns)

Sử dụng các mẫu này khi kỹ năng cần tạo ra kết quả đầu ra nhất quán, chất lượng cao.

## Mẫu Khuôn Khổ Định Sẵn (Template Pattern)

Cung cấp các biểu mẫu (templates) cho định dạng đầu ra. Điều chỉnh mức độ nghiêm ngặt sao cho khớp với nhu cầu của bạn.

**Đối với các yêu cầu nghiêm ngặt (như phản hồi API hoặc các định dạng dữ liệu cố định):**

```markdown
## Cấu trúc báo cáo

LUÔN LUÔN sử dụng chính xác cấu trúc biểu mẫu này:

# [Analysis Title]

## Tóm tắt điều hành (Executive summary)
[One-paragraph overview of key findings]

## Các phát hiện chính (Key findings)
- Phát hiện 1 kèm dữ liệu chứng minh
- Phát hiện 2 kèm dữ liệu chứng minh
- Phát hiện 3 kèm dữ liệu chứng minh

## Khuyến nghị (Recommendations)
1. Khuyến nghị cụ thể có tính hành động
2. Khuyến nghị cụ thể có tính hành động
```

**Đối với hướng dẫn linh hoạt (khi sự thích ứng theo tình huống mang lại lợi ích):**

```markdown
## Cấu trúc báo cáo

Dưới đây là định dạng mặc định hợp lý, nhưng hãy sử dụng sự phán đoán tốt nhất của bạn:

# [Analysis Title]

## Tóm tắt điều hành
[Overview]

## Các phát hiện chính
[Adapt sections based on what you discover]

## Khuyến nghị
[Tailor to the specific context]

Điều chỉnh các mục khi cần thiết cho phù hợp với loại hình phân tích cụ thể.
```

## Mẫu Ví Dự Minh Họa (Examples Pattern)

Đối với các kỹ năng mà chất lượng đầu ra phụ thuộc vào việc nhìn thấy các ví dụ mẫu, hãy cung cấp các cặp đầu vào/đầu ra (input/output pairs):

```markdown
## Định dạng thông điệp commit (Commit message format)

Tạo các thông điệp commit tuân theo các ví dụ sau:

**Ví dụ 1:**
Đầu vào (Input): Đã thêm xác thực người dùng bằng JWT tokens
Đầu ra (Output):
```
feat(auth): implement JWT-based authentication

Add login endpoint and token validation middleware
```

**Ví dụ 2:**
Đầu vào (Input): Đã sửa lỗi ngày tháng hiển thị không chính xác trong các báo cáo
Đầu ra (Output):
```
fix(reports): correct date formatting in timezone conversion

Use UTC timestamps consistently across report generation
```

Hãy tuân theo phong cách này: type(scope): mô tả ngắn gọn, sau đó là phần giải thích chi tiết.
```

Các ví dụ giúp Claude hiểu rõ phong cách mong muốn và mức độ chi tiết cụ thể hơn nhiều so với việc chỉ dùng lời mô tả đơn thuần.
FILE:scripts/quick_validate.py
#!/usr/bin/env python3
"""
Quick validation script for skills - minimal version
"""

import sys
import os
import re
import yaml
from pathlib import Path

def validate_skill(skill_path):
    """Basic validation of a skill"""
    skill_path = Path(skill_path)

    # Check SKILL.md exists
    skill_md = skill_path / 'SKILL.md'
    if not skill_md.exists():
        return False, "SKILL.md not found"

    # Read and validate frontmatter
    content = skill_md.read_text()
    if not content.startswith('---'):
        return False, "No YAML frontmatter found"

    # Extract frontmatter
    match = re.match(r'^---\n(.*?)\n---', content, re.DOTALL)
    if not match:
        return False, "Invalid frontmatter format"

    frontmatter_text = match.group(1)

    # Parse YAML frontmatter
    try:
        frontmatter = yaml.safe_load(frontmatter_text)
        if not isinstance(frontmatter, dict):
            return False, "Frontmatter must be a YAML dictionary"
    except yaml.YAMLError as e:
        return False, f"Invalid YAML in frontmatter: {e}"

    # Define allowed properties
    ALLOWED_PROPERTIES = {'name', 'description', 'license', 'allowed-tools', 'metadata'}

    # Check for unexpected properties (excluding nested keys under metadata)
    unexpected_keys = set(frontmatter.keys()) - ALLOWED_PROPERTIES
    if unexpected_keys:
        return False, (
            f"Unexpected key(s) in SKILL.md frontmatter: {', '.join(sorted(unexpected_keys))}. "
            f"Allowed properties are: {', '.join(sorted(ALLOWED_PROPERTIES))}"
        )

    # Check required fields
    if 'name' not in frontmatter:
        return False, "Missing 'name' in frontmatter"
    if 'description' not in frontmatter:
        return False, "Missing 'description' in frontmatter"

    # Extract name for validation
    name = frontmatter.get('name', '')
    if not isinstance(name, str):
        return False, f"Name must be a string, got {type(name).__name__}"
    name = name.strip()
    if name:
        # Check naming convention (hyphen-case: lowercase with hyphens)
        if not re.match(r'^[a-z0-9-]+$', name):
            return False, f"Name '{name}' should be hyphen-case (lowercase letters, digits, and hyphens only)"
        if name.startswith('-') or name.endswith('-') or '--' in name:
            return False, f"Name '{name}' cannot start/end with hyphen or contain consecutive hyphens"
        # Check name length (max 64 characters per spec)
        if len(name) > 64:
            return False, f"Name is too long ({len(name)} characters). Maximum is 64 characters."

    # Extract and validate description
    description = frontmatter.get('description', '')
    if not isinstance(description, str):
        return False, f"Description must be a string, got {type(description).__name__}"
    description = description.strip()
    if description:
        # Check for angle brackets
        if '<' in description or '>' in description:
            return False, "Description cannot contain angle brackets (< or >)"
        # Check description length (max 1024 characters per spec)
        if len(description) > 1024:
            return False, f"Description is too long ({len(description)} characters). Maximum is 1024 characters."

    return True, "Skill is valid!"

if __name__ == "__main__":
    if len(sys.argv) != 2:
        print("Usage: python quick_validate.py <skill_directory>")
        sys.exit(1)
    
    valid, message = validate_skill(sys.argv[1])
    print(message)
    sys.exit(0 if valid else 1)
FILE:scripts/init_skill.py
#!/usr/bin/env python3
"""
Skill Initializer - Creates a new skill from template

Usage:
    init_skill.py <skill-name> --path <path>

Examples:
    init_skill.py my-new-skill --path skills/public
    init_skill.py my-api-helper --path skills/private
    init_skill.py custom-skill --path /custom/location
"""

import sys
from pathlib import Path


SKILL_TEMPLATE = """---
name: {skill_name}
description: [TODO: Complete and informative explanation of what the skill does and when to use it. Include WHEN to use this skill - specific scenarios, file types, or tasks that trigger it.]
---

# {skill_title}

## Overview

[TODO: 1-2 sentences explaining what this skill enables]

## Resources

This skill includes example resource directories that demonstrate how to organize different types of bundled resources:

### scripts/
Executable code (Python/Bash/etc.) that can be run directly to perform specific operations.

### references/
Documentation and reference material intended to be loaded into context to inform Claude's process and thinking.

### assets/
Files not intended to be loaded into context, but rather used within the output Claude produces.

---

**Any unneeded directories can be deleted.** Not every skill requires all three types of resources.
"""

EXAMPLE_SCRIPT = '''#!/usr/bin/env python3
"""
Example helper script for {skill_name}

This is a placeholder script that can be executed directly.
Replace with actual implementation or delete if not needed.
"""

def main():
    print("This is an example script for {skill_name}")
    # TODO: Add actual script logic here

if __name__ == "__main__":
    main()
'''

EXAMPLE_REFERENCE = """# Reference Documentation for {skill_title}

This is a placeholder for detailed reference documentation.
Replace with actual reference content or delete if not needed.
"""

EXAMPLE_ASSET = """# Example Asset File

This placeholder represents where asset files would be stored.
Replace with actual asset files (templates, images, fonts, etc.) or delete if not needed.
"""


def title_case_skill_name(skill_name):
    """Convert hyphenated skill name to Title Case for display."""
    return ' '.join(word.capitalize() for word in skill_name.split('-'))


def init_skill(skill_name, path):
    """Initialize a new skill directory with template SKILL.md."""
    skill_dir = Path(path).resolve() / skill_name

    if skill_dir.exists():
        print(f"❌ Error: Skill directory already exists: {skill_dir}")
        return None

    try:
        skill_dir.mkdir(parents=True, exist_ok=False)
        print(f"✅ Created skill directory: {skill_dir}")
    except Exception as e:
        print(f"❌ Error creating directory: {e}")
        return None

    skill_title = title_case_skill_name(skill_name)
    skill_content = SKILL_TEMPLATE.format(skill_name=skill_name, skill_title=skill_title)

    skill_md_path = skill_dir / 'SKILL.md'
    try:
        skill_md_path.write_text(skill_content)
        print("✅ Created SKILL.md")
    except Exception as e:
        print(f"❌ Error creating SKILL.md: {e}")
        return None

    try:
        scripts_dir = skill_dir / 'scripts'
        scripts_dir.mkdir(exist_ok=True)
        example_script = scripts_dir / 'example.py'
        example_script.write_text(EXAMPLE_SCRIPT.format(skill_name=skill_name))
        example_script.chmod(0o755)
        print("✅ Created scripts/example.py")

        references_dir = skill_dir / 'references'
        references_dir.mkdir(exist_ok=True)
        example_reference = references_dir / 'api_reference.md'
        example_reference.write_text(EXAMPLE_REFERENCE.format(skill_title=skill_title))
        print("✅ Created references/api_reference.md")

        assets_dir = skill_dir / 'assets'
        assets_dir.mkdir(exist_ok=True)
        example_asset = assets_dir / 'example_asset.txt'
        example_asset.write_text(EXAMPLE_ASSET)
        print("✅ Created assets/example_asset.txt")
    except Exception as e:
        print(f"❌ Error creating resource directories: {e}")
        return None

    print(f"\n✅ Skill '{skill_name}' initialized successfully at {skill_dir}")
    return skill_dir


def main():
    if len(sys.argv) < 4 or sys.argv[2] != '--path':
        print("Usage: init_skill.py <skill-name> --path <path>")
        sys.exit(1)

    skill_name = sys.argv[1]
    path = sys.argv[3]

    print(f"🚀 Initializing skill: {skill_name}")
    print(f"   Location: {path}")
    print()

    result = init_skill(skill_name, path)
    sys.exit(0 if result else 1)


if __name__ == "__main__":
    main()
FILE:scripts/package_skill.py
#!/usr/bin/env python3
"""
Skill Packager - Creates a distributable .skill file of a skill folder

Usage:
    python utils/package_skill.py <path/to/skill-folder> [output-directory]

Example:
    python utils/package_skill.py skills/public/my-skill
    python utils/package_skill.py skills/public/my-skill ./dist
"""

import sys
import zipfile
from pathlib import Path
from quick_validate import validate_skill


def package_skill(skill_path, output_dir=None):
    """Package a skill folder into a .skill file."""
    skill_path = Path(skill_path).resolve()

    if not skill_path.exists():
        print(f"❌ Error: Skill folder not found: {skill_path}")
        return None

    if not skill_path.is_dir():
        print(f"❌ Error: Path is not a directory: {skill_path}")
        return None

    skill_md = skill_path / "SKILL.md"
    if not skill_md.exists():
        print(f"❌ Error: SKILL.md not found in {skill_path}")
        return None

    print("🔍 Validating skill...")
    valid, message = validate_skill(skill_path)
    if not valid:
        print(f"❌ Validation failed: {message}")
        print("   Please fix the validation errors before packaging.")
        return None
    print(f"✅ {message}\n")

    skill_name = skill_path.name
    if output_dir:
        output_path = Path(output_dir).resolve()
        output_path.mkdir(parents=True, exist_ok=True)
    else:
        output_path = Path.cwd()

    skill_filename = output_path / f"{skill_name}.skill"

    try:
        with zipfile.ZipFile(skill_filename, 'w', zipfile.ZIP_DEFLATED) as zipf:
            for file_path in skill_path.rglob('*'):
                if file_path.is_file():
                    arcname = file_path.relative_to(skill_path.parent)
                    zipf.write(file_path, arcname)
                    print(f"  Added: {arcname}")

        print(f"\n✅ Successfully packaged skill to: {skill_filename}")
        return skill_filename

    except Exception as e:
        print(f"❌ Error creating .skill file: {e}")
        return None


def main():
    if len(sys.argv) < 2:
        print("Usage: python utils/package_skill.py <path/to/skill-folder> [output-directory]")
        sys.exit(1)

    skill_path = sys.argv[1]
    output_dir = sys.argv[2] if len(sys.argv) > 2 else None

    print(f"📦 Packaging skill: {skill_path}")
    if output_dir:
        print(f"   Output directory: {output_dir}")
    print()

    result = package_skill(skill_path, output_dir)
    sys.exit(0 if result else 1)


if __name__ == "__main__":
    main()