Skillsmp Searcher

# Environment Variables Example / 环境变量示例文件
# 环境变量示例文件
#
# Copy this file to .env (add .env to .gitignore) and fill in your actual values
# 复制此文件为 .env（将 .env 添加到 .gitignore）并填入您的实际值

# SkillsMP API Key
# Get your API key from: https://skillsmp.com/
# 从以下地址获取您的API密钥：https://skillsmp.com/
SKILLSMP_API_KEY=sk_live_skillsmp_your_api_key_here

# Optional: Custom API base URL (for testing or enterprise deployments)
# 可选：自定义API基础URL（用于测试或企业部署）
# SKILLSMP_API_BASE_URL=https://skillsmp.com/api/v1

name: CD

on:
  push:
    branches: [ main ]
  workflow_dispatch:

jobs:
  package:
    name: Package and Release
    runs-on: ubuntu-latest
    permissions:
      contents: write

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.11'

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install requests

      - name: Validate skill structure
        run: |
          if [ ! -f "skills/skillsmp-searcher/SKILL.md" ]; then
            echo "Error: SKILL.md not found"
            exit 1
          fi
          if [ ! -d "skills/skillsmp-searcher/scripts" ]; then
            echo "Error: scripts directory not found"
            exit 1
          fi
          echo "Skill structure validation passed"

      - name: Package skill
        run: |
          cd skills/skillsmp-searcher
          zip -r ../../skillsmp-searcher.skill . -x "*.git*" "*.pyc" "__pycache__/*"

      - name: Generate release notes
        id: release_notes
        run: |
          echo "## 🚀 Automated Release" > release_notes.md
          echo "" >> release_notes.md
          echo "This is an automated release from the main branch." >> release_notes.md
          echo "" >> release_notes.md
          echo "### Changes" >> release_notes.md
          echo "- Latest changes from the main branch" >> release_notes.md
          echo "" >> release_notes.md
          echo "### Installation" >> release_notes.md
          echo '```bash' >> release_notes.md
          echo "claude skill install skillsmp-searcher.skill" >> release_notes.md
          echo '```' >> release_notes.md

      - name: Create Release
        uses: softprops/action-gh-release@v1
        with:
          name: Latest Release
          body_path: release_notes.md
          files: skillsmp-searcher.skill
          tag_name: latest
          draft: false
          prerelease: false
          fail_on_unmatched_files: true
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

name: CI

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]

jobs:
  lint:
    name: Code Quality
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.11'

      - name: Install linting tools
        run: |
          python -m pip install --upgrade pip
          pip install black flake8 isort mypy types-requests

      - name: Check code formatting with Black
        run: black --check skills/skillsmp-searcher/scripts/

      - name: Check code style with Flake8
        run: |
          flake8 skills/skillsmp-searcher/scripts/ --count --select=E9,F63,F7,F82 --show-source --statistics
          flake8 skills/skillsmp-searcher/scripts/ --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics

      - name: Check import sorting with isort
        run: isort --check-only skills/skillsmp-searcher/scripts/

      - name: Type checking with mypy
        run: mypy skills/skillsmp-searcher/scripts/ --ignore-missing-imports

  test:
    name: Test (Python ${{ matrix.python }}, ${{ matrix.os }})
    runs-on: ${{ matrix.os }}
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest, windows-latest]
        python: ['3.9', '3.10', '3.11', '3.12']

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Set up Python ${{ matrix.python }}
        uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python }}

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install pytest pytest-mock requests

      - name: Run tests
        run: pytest tests/ -v

# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class

# C extensions
*.so

# Distribution / packaging
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
*.egg-info/
.installed.cfg
*.egg

# PyInstaller
*.manifest
*.spec

# Unit test / coverage reports
htmlcov/
.tox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*.cover
.hypothesis/
.pytest_cache/

# Environments
.env
.venv
env/
venv/
ENV/
env.bak/
venv.bak/

# IDEs
.vscode/
.idea/
*.swp
*.swo
*~

# OS
.DS_Store
Thumbs.db

# Skills specific
*.skill

# API keys (keep template, ignore real keys if created separately)
skills/skillsmp-searcher/references/api_key_real.txt

# Worktrees
.worktrees
worktrees

                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/

   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

   1. Definitions.

      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.

      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.

      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.

      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.

      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.

      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.

      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).

      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.

      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."

      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.

   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.

   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.

   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:

      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and

      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and

      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and

      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.

      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.

   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.

   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.

   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.

   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.

   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.

   END OF TERMS AND CONDITIONS

   APPENDIX: How to apply the Apache License to your work.

      To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "[]"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. We also recommend that a
      file or class name and description of purpose be included on the
      same "printed page" as the copyright notice for easier
      identification within third-party archives.

   Copyright [yyyy] [name of copyright owner]

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.

[tool.black]
line-length = 100
target-version = ['py39', 'py310', 'py311', 'py312']
include = '\.pyi?$'

[tool.isort]
profile = "black"
line_length = 100
multi_line_output = 3
include_trailing_comma = true
force_grid_wrap = 0
use_parentheses = true
ensure_newline_before_comments = true

[pytest]
testpaths = tests
python_files = test_*.py
python_classes = Test*
python_functions = test_*
addopts = --verbose
markers =
    unit: Unit tests
    integration: Integration tests

# SkillsMP API Key
# Get your API key from: https://skillsmp.com/
# Replace the text below with your actual API key

sk_live_skillsmp_your_api_key_here

# Core dependencies
requests>=2.31.0

# Testing
pytest>=7.4.0
pytest-cov>=4.1.0
pytest-mock>=3.11.0

# Code quality
black>=23.7.0
flake8>=6.1.0
isort>=5.12.0
mypy>=1.5.0

# Type stubs
types-requests>=2.31.0

#!/usr/bin/env python3
"""
SkillsMP AI Semantic Search Script
Search for skills using AI-powered semantic search on SkillsMP marketplace.
"""

import requests
import argparse
import json
import sys
import os

# API Configuration
BASE_URL = "https://skillsmp.com/api/v1"
API_KEY_FILE = os.path.join(os.path.dirname(os.path.dirname(__file__)), "references", "api_key.txt")


def load_api_key():
    """Load API key from references/api_key.txt"""
    try:
        with open(API_KEY_FILE, 'r') as f:
            api_key = f.read().strip()
            if not api_key:
                raise ValueError("API key file is empty")
            return api_key
    except FileNotFoundError:
        print(f"Error: API key file not found at {API_KEY_FILE}")
        print("Please create the file and add your SkillsMP API key.")
        sys.exit(1)
    except Exception as e:
        print(f"Error loading API key: {e}")
        sys.exit(1)


def ai_search(query, api_key=None):
    """
    Search skills using AI semantic search.

    Args:
        query: Natural language search query
        api_key: SkillsMP API key

    Returns:
        dict: Search results
    """
    if api_key is None:
        api_key = load_api_key()

    url = f"{BASE_URL}/skills/ai-search"
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
    params = {
        "q": query
    }

    try:
        response = requests.get(url, headers=headers, params=params)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.HTTPError as e:
        print(f"HTTP Error: {e}")
        if response.status_code == 401:
            error_data = response.json()
            print(f"API Error: {error_data.get('error', {}).get('message', 'Authentication failed')}")
        sys.exit(1)
    except requests.exceptions.RequestException as e:
        print(f"Request Error: {e}")
        sys.exit(1)


def format_results(results):
    """Format search results for display"""
    if not results.get("success", True):
        error = results.get("error", {})
        print(f"Error: {error.get('code', 'UNKNOWN')} - {error.get('message', 'Unknown error')}")
        return

    data = results.get("data", {})
    skills = data.get("skills", [])

    print(f"\n=== AI Search Results ===\n")

    if not skills:
        print("No skills found matching your query.")
        return

    for i, skill in enumerate(skills, 1):
        name = skill.get("name", "Unknown")
        description = skill.get("description", "No description")
        relevance = skill.get("relevance_score", 0)
        stars = skill.get("stars", 0)
        author = skill.get("author", "Unknown")

        print(f"{i}. {name}")
        print(f"   Author: {author} | Stars: {stars} | Relevance: {relevance:.2f}")
        print(f"   Description: {description[:100]}{'...' if len(description) > 100 else ''}")
        print()


def main():
    parser = argparse.ArgumentParser(description="AI-powered semantic search on SkillsMP marketplace")
    parser.add_argument("query", help="Natural language search query")
    parser.add_argument("--json", action="store_true", help="Output raw JSON")
    parser.add_argument("--api-key", help="API key (overrides file)")

    args = parser.parse_args()

    results = ai_search(
        query=args.query,
        api_key=args.api_key
    )

    if args.json:
        print(json.dumps(results, indent=2))
    else:
        format_results(results)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
SkillsMP Keyword Search Script
Search for skills using keywords on SkillsMP marketplace.
"""

import requests
import argparse
import json
import sys
import os

# API Configuration
BASE_URL = "https://skillsmp.com/api/v1"
API_KEY_FILE = os.path.join(os.path.dirname(os.path.dirname(__file__)), "references", "api_key.txt")


def load_api_key():
    """Load API key from references/api_key.txt"""
    try:
        with open(API_KEY_FILE, 'r') as f:
            api_key = f.read().strip()
            if not api_key:
                raise ValueError("API key file is empty")
            return api_key
    except FileNotFoundError:
        print(f"Error: API key file not found at {API_KEY_FILE}")
        print("Please create the file and add your SkillsMP API key.")
        sys.exit(1)
    except Exception as e:
        print(f"Error loading API key: {e}")
        sys.exit(1)


def search_skills(query, page=1, limit=20, sort_by="stars", api_key=None):
    """
    Search skills using keyword search.

    Args:
        query: Search keyword
        page: Page number (default: 1)
        limit: Items per page (default: 20, max: 100)
        sort_by: Sort by 'stars' or 'recent' (default: 'stars')
        api_key: SkillsMP API key

    Returns:
        dict: Search results
    """
    if api_key is None:
        api_key = load_api_key()

    url = f"{BASE_URL}/skills/search"
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
    params = {
        "q": query,
        "page": page,
        "limit": min(limit, 100),
        "sortBy": sort_by
    }

    try:
        response = requests.get(url, headers=headers, params=params)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.HTTPError as e:
        print(f"HTTP Error: {e}")
        if response.status_code == 401:
            error_data = response.json()
            print(f"API Error: {error_data.get('error', {}).get('message', 'Authentication failed')}")
        sys.exit(1)
    except requests.exceptions.RequestException as e:
        print(f"Request Error: {e}")
        sys.exit(1)


def format_results(results):
    """Format search results for display"""
    if not results.get("success", True):
        error = results.get("error", {})
        print(f"Error: {error.get('code', 'UNKNOWN')} - {error.get('message', 'Unknown error')}")
        return

    data = results.get("data", {})
    skills = data.get("skills", [])
    total = data.get("total", 0)

    print(f"\n=== Search Results ===")
    print(f"Total: {total} skills found\n")

    for i, skill in enumerate(skills, 1):
        name = skill.get("name", "Unknown")
        description = skill.get("description", "No description")
        stars = skill.get("stars", 0)
        author = skill.get("author", "Unknown")

        print(f"{i}. {name}")
        print(f"   Author: {author} | Stars: {stars}")
        print(f"   Description: {description[:100]}{'...' if len(description) > 100 else ''}")
        print()


def main():
    parser = argparse.ArgumentParser(description="Search SkillsMP marketplace for skills")
    parser.add_argument("query", help="Search keyword")
    parser.add_argument("--page", type=int, default=1, help="Page number (default: 1)")
    parser.add_argument("--limit", type=int, default=20, help="Items per page (default: 20, max: 100)")
    parser.add_argument("--sort", choices=["stars", "recent"], default="stars",
                       help="Sort by: 'stars' (default) or 'recent'")
    parser.add_argument("--json", action="store_true", help="Output raw JSON")
    parser.add_argument("--api-key", help="API key (overrides file)")

    args = parser.parse_args()

    results = search_skills(
        query=args.query,
        page=args.page,
        limit=args.limit,
        sort_by=args.sort,
        api_key=args.api_key
    )

    if args.json:
        print(json.dumps(results, indent=2))
    else:
        format_results(results)


if __name__ == "__main__":
    main()

# Worktrees directory
.worktrees/

                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/

   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

   1. Definitions.

      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.

      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.

      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.

      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.

      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.

      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.

      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).

      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.

      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."

      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.

   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.

   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.

   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:

      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and

      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and

      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and

      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.

      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.

   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.

   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.

   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.

   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.

   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.

   END OF TERMS AND CONDITIONS

   APPENDIX: How to apply the Apache License to your work.

      To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "[]"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. We also recommend that a
      file or class name and description of purpose be included on the
      same "printed page" as the copyright notice for easier
      identification within third-party archives.

   Copyright [yyyy] [name of copyright owner]

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.

# SkillsMP API Key
# Get your API key from: https://skillsmp.com/
# Replace the text below with your actual API key

sk_live_skillsmp_your_api_key_here

#!/usr/bin/env python3
"""
SkillsMP AI Semantic Search Script
Search for skills using AI-powered semantic search on SkillsMP marketplace.
"""

import argparse
import json
import sys
from typing import Optional

from utils import APIRequestError, SkillsMPError, make_api_request


def ai_search(query: str, api_key: Optional[str] = None) -> dict:
    """
    Search skills using AI semantic search.

    Args:
        query: Natural language search query
        api_key: SkillsMP API key

    Returns:
        dict: Search results

    Raises:
        SkillsMPError: If the search fails
    """
    params = {"q": query}
    return make_api_request("/skills/ai-search", params, api_key=api_key)


def format_results(results):
    """Format search results for display"""
    if not results.get("success", True):
        error = results.get("error", {})
        print(f"Error: {error.get('code', 'UNKNOWN')} - {error.get('message', 'Unknown error')}")
        return

    data = results.get("data", {})
    skills = data.get("skills", [])

    print(f"\n=== AI Search Results ===\n")

    if not skills:
        print("No skills found matching your query.")
        return

    for i, skill in enumerate(skills, 1):
        name = skill.get("name", "Unknown")
        description = skill.get("description", "No description")
        relevance = skill.get("relevance_score", 0)
        stars = skill.get("stars", 0)
        author = skill.get("author", "Unknown")

        print(f"{i}. {name}")
        print(f"   Author: {author} | Stars: {stars} | Relevance: {relevance:.2f}")
        print(f"   Description: {description[:100]}{'...' if len(description) > 100 else ''}")
        print()


def main():
    parser = argparse.ArgumentParser(
        description="AI-powered semantic search on SkillsMP marketplace"
    )
    parser.add_argument("query", help="Natural language search query")
    parser.add_argument("--json", action="store_true", help="Output raw JSON")
    parser.add_argument("--api-key", help="API key (overrides file)")

    args = parser.parse_args()

    try:
        results = ai_search(query=args.query, api_key=args.api_key)

        if args.json:
            print(json.dumps(results, indent=2))
        else:
            format_results(results)

    except SkillsMPError as e:
        print(f"Error: {e}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
SkillsMP Skill Update Checker
Check for updates to installed skills by comparing local file times with SkillsMP API.
"""

import argparse
import json
import re
import sys
import time
from datetime import datetime
from pathlib import Path
from typing import Any, Dict, List, Optional

from utils import (
    APIRequestError,
    SkillsMPError,
    get_claude_skills_dir,
    load_api_key,
    make_api_request,
)


def get_skill_name_from_md(skill_md_path: Path) -> Optional[str]:
    """
    Extract skill name from SKILL.md frontmatter.

    Args:
        skill_md_path: Path to SKILL.md file

    Returns:
        Skill name or None if not found
    """
    try:
        with open(skill_md_path, "r", encoding="utf-8") as f:
            content = f.read()

            # Extract name from YAML frontmatter
            match = re.search(r"^name:\s*(.+)$", content, re.MULTILINE)
            if match:
                return match.group(1).strip()
    except Exception:
        pass
    return None


def get_installed_skills_with_metadata(skills_dir: Path) -> List[Dict]:
    """
    Scan local skills directory and extract metadata.

    Args:
        skills_dir: Path to Claude skills directory

    Returns:
        List of dicts with skill metadata: name, path, local_modified
    """
    skills: List[Dict[str, Any]] = []

    if not skills_dir.exists():
        return skills

    for skill_dir in skills_dir.iterdir():
        if not skill_dir.is_dir():
            continue

        skill_md = skill_dir / "SKILL.md"
        if not skill_md.exists():
            continue

        skill_name = get_skill_name_from_md(skill_md)
        if not skill_name:
            continue

        # Get directory modification time as Unix timestamp
        local_mtime = skill_dir.stat().st_mtime

        skills.append(
            {
                "name": skill_name,
                "path": skill_dir,
                "local_modified": local_mtime,
                "local_modified_date": datetime.fromtimestamp(local_mtime).strftime("%Y-%m-%d"),
            }
        )

    return skills


def search_skill_on_skillsmp(skill_name: str, api_key: Optional[str] = None) -> Optional[Dict]:
    """
    Search for a skill on SkillsMP marketplace.

    Args:
        skill_name: Name of the skill to search for
        api_key: SkillsMP API key

    Returns:
        Skill data from API or None if not found
    """
    try:
        params = {"q": skill_name, "limit": 5, "sortBy": "stars"}
        result = make_api_request("/skills/search", params, api_key=api_key)

        if not result.get("success"):
            return None

        skills_list = result.get("data", {}).get("skills", [])
        if not skills_list:
            return None

        # Find exact match by name
        for skill in skills_list:
            if skill.get("name", "").lower() == skill_name.lower():
                return skill

        # If no exact match, return first result (best match)
        return skills_list[0]

    except (APIRequestError, SkillsMPError):
        return None


def format_timestamp(unix_timestamp: int) -> str:
    """Convert Unix timestamp to readable date."""
    return datetime.fromtimestamp(unix_timestamp).strftime("%Y-%m-%d")


def check_skill_updates(skills_dir: Optional[Path] = None, api_key: Optional[str] = None) -> Dict:
    """
    Check all installed skills for available updates.

    Args:
        skills_dir: Custom skills directory
        api_key: API key for SkillsMP API

    Returns:
        Dict with 'updates', 'up_to_date', 'not_found', 'errors' lists
    """
    if skills_dir is None:
        skills_dir = get_claude_skills_dir()

    installed_skills = get_installed_skills_with_metadata(skills_dir)

    result: Dict[str, List[Any]] = {
        "updates": [],  # Skills with remote updates
        "up_to_date": [],  # Skills that are current
        "not_found": [],  # Skills not found on SkillsMP
        "errors": [],  # Skills that had errors
    }

    if not installed_skills:
        return result

    print(f"🔍 Checking {len(installed_skills)} installed skills for updates...\n")

    for i, skill in enumerate(installed_skills, 1):
        skill_name = skill["name"]
        local_mtime = skill["local_modified"]

        # Show progress
        print(f"[{i}/{len(installed_skills)}] Checking {skill_name}...", end=" ")

        # Search on SkillsMP
        remote_skill = search_skill_on_skillsmp(skill_name, api_key=api_key)

        if not remote_skill:
            print("❓ Not found on SkillsMP")
            result["not_found"].append(skill)
            # Add small delay to avoid rate limiting
            time.sleep(0.3)
            continue

        # Extract remote data
        remote_updated = remote_skill.get("updatedAt", 0)
        remote_updated_date = format_timestamp(remote_updated)
        github_url = remote_skill.get("githubUrl", "")
        skill_url = remote_skill.get("skillUrl", "")
        stars = remote_skill.get("stars", 0)

        # Compare timestamps (allow 1 second tolerance for file system precision)
        if remote_updated > local_mtime + 1:
            print(f"⚠️ Update available!")
            print(f"   Local: {skill['local_modified_date']} | Remote: {remote_updated_date}")
            result["updates"].append(
                {
                    "name": skill_name,
                    "local_date": skill["local_modified_date"],
                    "remote_date": remote_updated_date,
                    "local_timestamp": local_mtime,
                    "remote_timestamp": remote_updated,
                    "github_url": github_url,
                    "skill_url": skill_url,
                    "stars": stars,
                }
            )
        else:
            print("✅ Up to date")
            result["up_to_date"].append(skill)

        # Add small delay to avoid rate limiting
        time.sleep(0.3)

    return result


def format_update_summary(result: Dict):
    """Format and display update check results."""
    updates = result["updates"]
    up_to_date = result["up_to_date"]
    not_found = result["not_found"]
    errors = result["errors"]

    print("\n" + "=" * 60)
    print("📊 UPDATE CHECK SUMMARY")
    print("=" * 60)

    # Show updates
    if updates:
        print(f"\n⚠️ {len(updates)} skill(s) with potential updates:\n")
        for i, update in enumerate(updates, 1):
            print(f"{i}. {update['name']}")
            print(f"   Local: {update['local_date']} | SkillsMP: {update['remote_date']}")
            print(f"   Stars: {update['stars']}")
            print(f"   GitHub: {update['github_url']}")
            print()
    else:
        print("\n✨ No updates found - all checked skills are up to date!\n")

    # Show not found
    if not_found:
        print(f"❓ {len(not_found)} skill(s) not found on SkillsMP:")
        for skill in not_found:
            print(f"   - {skill['name']}")
        print()

    # Show errors
    if errors:
        print(f"❌ {len(errors)} skill(s) had errors:")
        for error in errors:
            print(f"   - {error['name']}: {error['error']}")
        print()

    # Show summary
    total_checked = len(updates) + len(up_to_date)
    print(f"Total checked: {total_checked}")
    print(f"Up to date: {len(up_to_date)}")
    print(f"Updates available: {len(updates)}")
    print(f"Not found: {len(not_found)}")
    print(f"Errors: {len(errors)}")


def interactive_details_loop(result: Dict, api_key: Optional[str] = None):
    """
    Interactive loop for viewing skill details and updating.

    Args:
        result: Update check result from check_skill_updates()
        api_key: API key for API requests
    """
    updates = result["updates"]

    if not updates:
        return

    while True:
        print("\n" + "=" * 60)
        print(
            "View details? Enter skill number (1-{}) or 'q' to quit:".format(len(updates)), end=" "
        )

        try:
            user_input = input().strip()

            if user_input.lower() == "q":
                print("👋 Exiting update checker.")
                break

            skill_index = int(user_input)
            if skill_index < 1 or skill_index > len(updates):
                print(f"❌ Invalid number. Please enter 1-{len(updates)} or 'q'")
                continue

            # Get selected update
            selected = updates[skill_index - 1]
            skill_name = selected["name"]
            github_url = selected["github_url"]

            # Import skill_diff to show details
            import subprocess

            print(f"\n🔍 Fetching details for {skill_name}...")
            subprocess.run(
                ["python", "skill_diff.py", skill_name],
                cwd=Path(__file__).parent,
                capture_output=False,
            )

            # Ask if user wants to update
            print("\n" + "=" * 60)
            print("Update this skill? [Y/n]:", end=" ")

            update_choice = input().strip().lower()

            if update_choice == "n":
                print("⏭️  Skipped")
                continue

            if update_choice in ("", "y", "yes"):
                # Import and run skill_downloader
                print(f"\n📦 Updating {skill_name}...")

                update_result = subprocess.run(
                    ["python", "skill_downloader.py", skill_name, "--github-url", github_url],
                    cwd=Path(__file__).parent,
                    capture_output=False,
                )

                if update_result.returncode == 0:
                    print(f"\n✅ {skill_name} updated successfully!")
                else:
                    print(f"\n❌ {skill_name} update failed")
            else:
                print("⏭️  Skipped (invalid input)")

        except ValueError:
            print("❌ Invalid input. Please enter a number or 'q'")
        except KeyboardInterrupt:
            print("\n👋 Exiting update checker.")
            break
        except Exception as e:
            print(f"❌ Error: {e}")


def main():
    parser = argparse.ArgumentParser(description="Check SkillsMP skills for available updates")
    parser.add_argument("--json", action="store_true", help="Output results in JSON format")
    parser.add_argument("--api-key", help="API key (overrides file)")
    parser.add_argument(
        "--no-interactive",
        action="store_true",
        help="Disable interactive mode (exit after showing summary)",
    )

    args = parser.parse_args()

    try:
        result = check_skill_updates(api_key=args.api_key)

        if args.json:
            # Convert to JSON-serializable format
            json_result = {
                "updates": result["updates"],
                "up_to_date": [
                    {"name": s["name"], "local_date": s["local_modified_date"]}
                    for s in result["up_to_date"]
                ],
                "not_found": [s["name"] for s in result["not_found"]],
                "errors": result["errors"],
            }
            print(json.dumps(json_result, indent=2))
        else:
            format_update_summary(result)

            # Interactive mode (only if updates found, not disabled, and in TTY)
            if result["updates"] and not args.no_interactive and sys.stdin.isatty():
                interactive_details_loop(result, api_key=args.api_key)

    except SkillsMPError as e:
        print(f"❌ Error: {e}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
SkillsMP Skill Installer
Install skills from SkillsMP marketplace with one command.
"""

import argparse
import json
import sys

import search_skills
from utils import install_skill, install_skill_from_url, list_installed_skills


def install_from_search_results(skill_index: int, search_query: str, **search_kwargs):
    """
    Search for a skill and install it by index.

    Args:
        skill_index: Index of the skill in search results (1-based)
        search_query: Search query to find the skill
        **search_kwargs: Additional arguments for search_skills
    """
    print(f"🔍 Searching for skills: {search_query}\n")

    # Search for skills
    results = search_skills.search_skills(search_query, **search_kwargs)

    if not results.get("success", True):
        error = results.get("error", {})
        print(f"❌ Search failed: {error.get('message', 'Unknown error')}")
        sys.exit(1)

    data = results.get("data", {})
    skills = data.get("skills", [])

    if not skills:
        print("❌ No skills found matching your query.")
        sys.exit(1)

    # Display search results
    print(f"Found {data.get('total', 0)} skills:\n")
    for i, skill in enumerate(skills, 1):
        name = skill.get("name", "Unknown")
        author = skill.get("author", "Unknown")
        stars = skill.get("stars", 0)
        print(f"{i}. {name} by {author} (⭐ {stars})")

    print()

    # Validate index
    if skill_index < 1 or skill_index > len(skills):
        print(f"❌ Invalid skill index. Please choose between 1 and {len(skills)}")
        sys.exit(1)

    selected_skill = skills[skill_index - 1]
    skill_name = selected_skill.get("name", "Unknown")
    skill_url = selected_skill.get("download_url", "")
    skill_id = selected_skill.get("id", "")

    # If no direct download URL, construct from repository
    if not skill_url and skill_id:
        # Assuming SkillsMP provides repository_url or similar
        repo_url = selected_skill.get("repository_url", "")
        if repo_url:
            # Try to get the latest release asset
            skill_url = f"{repo_url}/releases/latest/download/skill_name.skill"
        else:
            print(f"❌ Skill '{skill_name}' does not provide a download URL.")
            print("   Please visit SkillsMP marketplace to download manually.")
            sys.exit(1)

    print(f"📦 Installing: {skill_name}\n")

    try:
        if skill_url.startswith("http"):
            installed_path = install_skill_from_url(skill_url)
        else:
            # Assume it's a local path
            from pathlib import Path

            installed_path = install_skill(Path(skill_url))

        print(f"\n✅ Successfully installed: {skill_name}")
        print(f"   Location: {installed_path}")
        print("\n💡 You can now use this skill in Claude Code!")

    except Exception as e:
        print(f"\n❌ Installation failed: {e}")
        sys.exit(1)


def main():
    parser = argparse.ArgumentParser(description="Install skills from SkillsMP marketplace")
    subparsers = parser.add_subparsers(dest="command", help="Available commands")

    # Install command
    install_parser = subparsers.add_parser("install", help="Install a skill")
    install_parser.add_argument("query", help="Search query to find the skill (or direct URL/path)")
    install_parser.add_argument(
        "--index",
        type=int,
        default=1,
        help="Index of skill to install from search results (default: 1)",
    )
    install_parser.add_argument(
        "--page", type=int, default=1, help="Search page number (default: 1)"
    )
    install_parser.add_argument(
        "--sort",
        choices=["stars", "recent"],
        default="stars",
        help="Sort search results (default: stars)",
    )

    # List command
    list_parser = subparsers.add_parser("list", help="List installed skills")

    args = parser.parse_args()

    if not args.command:
        parser.print_help()
        sys.exit(1)

    try:
        if args.command == "install":
            # Check if query is a URL or local path
            if (
                args.query.startswith("http://")
                or args.query.startswith("https://")
                or args.query.endswith(".skill")
            ):
                # Direct installation from URL or file
                print(f"📦 Installing from: {args.query}\n")
                from pathlib import Path

                if args.query.startswith("http"):
                    installed_path = install_skill_from_url(args.query)
                else:
                    installed_path = install_skill(Path(args.query))

                print(f"\n✅ Successfully installed!")
                print(f"   Location: {installed_path}")
            else:
                # Search and install by index
                install_from_search_results(
                    skill_index=args.index,
                    search_query=args.query,
                    page=args.page,
                    sort_by=args.sort,
                )

        elif args.command == "list":
            skills = list_installed_skills()
            if skills:
                print("📚 Installed skills:\n")
                for skill in skills:
                    print(f"  • {skill}")
                print(f"\nTotal: {len(skills)} skills")
            else:
                print("❌ No skills installed.")

    except Exception as e:
        print(f"❌ Error: {e}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
SkillsMP Keyword Search Script
Search for skills using keywords on SkillsMP marketplace.
"""

import argparse
import json
import sys
from typing import Optional

from utils import APIRequestError, SkillsMPError, make_api_request


def search_skills(
    query: str,
    page: int = 1,
    limit: int = 20,
    sort_by: str = "stars",
    api_key: Optional[str] = None,
) -> dict:
    """
    Search skills using keyword search.

    Args:
        query: Search keyword
        page: Page number (default: 1)
        limit: Items per page (default: 20, max: 100)
        sort_by: Sort by 'stars' or 'recent' (default: 'stars')
        api_key: SkillsMP API key

    Returns:
        dict: Search results

    Raises:
        SkillsMPError: If the search fails
    """
    params = {"q": query, "page": page, "limit": min(limit, 100), "sortBy": sort_by}
    return make_api_request("/skills/search", params, api_key=api_key)


def format_results(results):
    """Format search results for display"""
    if not results.get("success", True):
        error = results.get("error", {})
        print(f"Error: {error.get('code', 'UNKNOWN')} - {error.get('message', 'Unknown error')}")
        return

    data = results.get("data", {})
    skills = data.get("skills", [])

    # Use total from API, fallback to actual count
    total = data.get("total", len(skills))
    if total == 0 and len(skills) > 0:
        total = len(skills)

    print(f"\n=== Search Results ===")
    print(f"Total: {total} skills found\n")

    for i, skill in enumerate(skills, 1):
        name = skill.get("name", "Unknown")
        description = skill.get("description", "No description")
        stars = skill.get("stars", 0)
        author = skill.get("author", "Unknown")

        print(f"{i}. {name}")
        print(f"   Author: {author} | Stars: {stars}")
        print(f"   Description: {description[:100]}{'...' if len(description) > 100 else ''}")
        print()


def main():
    parser = argparse.ArgumentParser(description="Search SkillsMP marketplace for skills")
    parser.add_argument("query", help="Search keyword")
    parser.add_argument("--page", type=int, default=1, help="Page number (default: 1)")
    parser.add_argument(
        "--limit", type=int, default=20, help="Items per page (default: 20, max: 100)"
    )
    parser.add_argument(
        "--sort",
        choices=["stars", "recent"],
        default="stars",
        help="Sort by: 'stars' (default) or 'recent'",
    )
    parser.add_argument("--json", action="store_true", help="Output raw JSON")
    parser.add_argument("--api-key", help="API key (overrides file)")

    args = parser.parse_args()

    try:
        results = search_skills(
            query=args.query,
            page=args.page,
            limit=args.limit,
            sort_by=args.sort,
            api_key=args.api_key,
        )

        if args.json:
            print(json.dumps(results, indent=2))
        else:
            format_results(results)

    except SkillsMPError as e:
        print(f"Error: {e}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
SkillsMP Skill Diff Viewer
Compare local skill with remote SkillsMP version.
"""

import argparse
import json
import re
import sys
from pathlib import Path
from typing import Any, Dict, List, Optional

from utils import APIRequestError, SkillsMPError, make_api_request


def extract_frontmatter(skill_md_path: Path) -> Dict[str, str]:
    """
    Extract YAML frontmatter from SKILL.md.

    Args:
        skill_md_path: Path to SKILL.md file

    Returns:
        Dict with frontmatter fields
    """
    try:
        with open(skill_md_path, "r", encoding="utf-8") as f:
            content = f.read()

            frontmatter = {}
            in_frontmatter = False

            for line in content.split("\n")[:30]:  # Check first 30 lines
                if line.strip() == "---":
                    if not in_frontmatter:
                        in_frontmatter = True
                    else:
                        break
                    continue

                if in_frontmatter:
                    match = re.match(r"^(\w+):\s*(.+)$", line)
                    if match:
                        key, value = match.groups()
                        frontmatter[key] = value.strip()

            return frontmatter
    except Exception:
        return {}


def get_skill_details_from_skillsmp(
    skill_name: str, api_key: Optional[str] = None
) -> Optional[Dict]:
    """
    Get detailed skill information from SkillsMP.

    Args:
        skill_name: Name of the skill
        api_key: SkillsMP API key

    Returns:
        Skill data or None if not found
    """
    try:
        params = {"q": skill_name, "limit": 5, "sortBy": "stars"}
        result = make_api_request("/skills/search", params, api_key=api_key)

        if not result.get("success"):
            return None

        skills_list = result.get("data", {}).get("skills", [])
        if not skills_list:
            return None

        # Find exact match
        for skill in skills_list:
            if skill.get("name", "").lower() == skill_name.lower():
                return skill

        # Return best match
        return skills_list[0]

    except (APIRequestError, SkillsMPError):
        return None


def compare_versions(local: Dict[str, str], remote: Dict[str, Any]) -> Dict[str, Any]:
    """
    Compare local and remote skill versions.

    Args:
        local: Local frontmatter data
        remote: Remote API data

    Returns:
        Dict with comparison results
    """
    differences: Dict[str, Any] = {
        "name_changed": False,
        "description_changed": False,
        "author_changed": False,
        "stars_changed": False,
        "fields": [],
    }
    fields_list: List[Dict[str, Any]] = differences["fields"]  # type: ignore[assignment]

    # Compare name
    local_name = local.get("name", "")
    remote_name = remote.get("name", "")
    if local_name and remote_name and local_name != remote_name:
        differences["name_changed"] = True
        fields_list.append({"field": "name", "local": local_name, "remote": remote_name})

    # Compare description
    local_desc = local.get("description", "")
    remote_desc = remote.get("description", "")
    if local_desc and remote_desc and local_desc != remote_desc:
        differences["description_changed"] = True
        fields_list.append(
            {"field": "description", "local": local_desc[:100], "remote": remote_desc[:100]}
        )

    # Compare author
    local_author = local.get("author", "")
    remote_author = remote.get("author", "")
    if local_author and remote_author and local_author != remote_author:
        differences["author_changed"] = True
        fields_list.append({"field": "author", "local": local_author, "remote": remote_author})

    # Compare stars (always check, not in frontmatter)
    remote_stars = remote.get("stars", 0)
    differences["stars_changed"] = True
    fields_list.append({"field": "stars", "remote": remote_stars})

    return differences


def format_diff_output(
    skill_name: str, local_path: Path, remote_data: Dict[str, Any], differences: Dict[str, Any]
):
    """Format and display diff comparison."""
    print("\n" + "=" * 60)
    print(f"📦 {skill_name} - Version Comparison")
    print("=" * 60)

    # Basic info
    print(f"\n📍 Local Path: {local_path}")
    print(f"🔗 GitHub: {remote_data.get('githubUrl', 'N/A')}")
    print(f"🌐 SkillsMP: {remote_data.get('skillUrl', 'N/A')}")
    print(f"⭐ Stars: {remote_data.get('stars', 0)}")
    print(f"📅 Last Updated: {remote_data.get('updatedAt', 'N/A')} " f"(Unix timestamp)")

    # Differences
    if differences["fields"]:
        print("\n📋 Changes Detected:\n")

        for field_data in differences["fields"]:
            field = field_data["field"]
            if field == "name":
                print(f"  Name:")
                print(f"    - Local:  {field_data['local']}")
                print(f"    + Remote: {field_data['remote']}")
            elif field == "description":
                print(f"  Description:")
                print(f"    - Local:  {field_data['local']}...")
                print(f"    + Remote: {field_data['remote']}...")
            elif field == "author":
                print(f"  Author:")
                print(f"    - Local:  {field_data['local']}")
                print(f"    + Remote: {field_data['remote']}")
            elif field == "stars":
                print(f"  Stars: {field_data['remote']}")
    else:
        print("\n✅ No differences detected in frontmatter")

    print("\n" + "=" * 60)


def main():
    parser = argparse.ArgumentParser(description="Compare local skill with SkillsMP remote version")
    parser.add_argument("skill_name", help="Name of the skill to compare")
    parser.add_argument(
        "--skill-dir",
        type=Path,
        help="Custom skills directory (default: ~/.claude/skills)",
    )
    parser.add_argument("--api-key", help="API key (overrides file)")
    parser.add_argument("--json", action="store_true", help="Output in JSON format")

    args = parser.parse_args()

    try:
        # Determine skill directory
        skill_dir = args.skill_dir
        if not skill_dir:
            from utils import get_claude_skills_dir

            skill_dir = get_claude_skills_dir()

        # Find local skill directory
        local_skill_path = None
        for item in skill_dir.iterdir():
            if item.is_dir():
                skill_md = item / "SKILL.md"
                if skill_md.exists():
                    # Extract name from frontmatter
                    frontmatter = extract_frontmatter(skill_md)
                    if frontmatter.get("name", "").lower() == args.skill_name.lower():
                        local_skill_path = item
                        break

        if not local_skill_path:
            print(f"❌ Skill '{args.skill_name}' not found locally")
            sys.exit(1)

        # Get remote data
        remote_data = get_skill_details_from_skillsmp(args.skill_name, api_key=args.api_key)

        if not remote_data:
            print(f"❌ Skill '{args.skill_name}' not found on SkillsMP")
            sys.exit(1)

        # Extract local frontmatter
        skill_md = local_skill_path / "SKILL.md"
        local_frontmatter = extract_frontmatter(skill_md)

        # Compare
        differences = compare_versions(local_frontmatter, remote_data)

        if args.json:
            # Output JSON
            json_output = {
                "skill_name": args.skill_name,
                "local_path": str(local_skill_path),
                "remote_data": remote_data,
                "differences": differences,
            }
            print(json.dumps(json_output, indent=2))
        else:
            # Format output
            format_diff_output(args.skill_name, local_skill_path, remote_data, differences)

    except SkillsMPError as e:
        print(f"❌ Error: {e}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
SkillsMP Skill Downloader
Download and install skill updates from GitHub or SkillsMP.
"""

import argparse
import os
import re
import shutil
import sys
import tempfile
import zipfile
from pathlib import Path
from typing import Optional

import requests
from utils import (
    APIRequestError,
    SkillsMPError,
    get_claude_skills_dir,
    install_skill,
    load_api_key,
    make_api_request,
)


def infer_download_url(github_url: str, skill_name: str) -> Optional[str]:
    """
    Infer download URL from GitHub URL.

    Attempts to construct GitHub Releases download URL.

    Args:
        github_url: GitHub repository URL
        skill_name: Name of the skill

    Returns:
        Download URL or None if cannot be inferred
    """
    # Extract owner/repo from GitHub URL
    # Format: https://github.com/owner/repo/tree/branch/skills/skill-name
    match = re.search(r"github\.com/([^/]+)/([^/]+)", github_url)
    if not match:
        return None

    owner, repo = match.groups()

    # Try GitHub Releases latest download
    # Common patterns: skill-name.skill, repo-name.skill, etc.
    possible_filenames = [
        f"{skill_name}.skill",
        f"{repo}.skill",
        f"{owner}-{repo}.skill",
    ]

    for filename in possible_filenames:
        download_url = f"https://github.com/{owner}/{repo}/releases/latest/download/{filename}"
        return download_url

    return None


def download_skill_file(download_url: str, dest_path: Path) -> bool:
    """
    Download skill file from URL.

    Args:
        download_url: URL to download from
        dest_path: Destination file path

    Returns:
        True if successful, False otherwise
    """
    try:
        print(f"📥 Downloading from: {download_url}")
        response = requests.get(download_url, stream=True, timeout=30)

        if response.status_code == 404:
            print("❌ Download failed: File not found (404)")
            return False

        response.raise_for_status()

        # Download to file
        dest_path.parent.mkdir(parents=True, exist_ok=True)
        with open(dest_path, "wb") as f:
            for chunk in response.iter_content(chunk_size=8192):
                if chunk:
                    f.write(chunk)

        print(f"✅ Downloaded to: {dest_path}")
        return True

    except requests.exceptions.RequestException as e:
        print(f"❌ Download failed: {e}")
        return False


def backup_skill_directory(skill_dir: Path) -> Optional[Path]:
    """
    Create backup of existing skill directory.

    Args:
        skill_dir: Path to skill directory

    Returns:
        Backup directory path or None if failed
    """
    try:
        parent = skill_dir.parent
        backup_name = f"{skill_dir.name}.backup"
        backup_path = parent / backup_name

        # Remove existing backup if present
        if backup_path.exists():
            shutil.rmtree(backup_path)

        # Create backup
        shutil.copytree(skill_dir, backup_path)
        print(f"📦 Backup created: {backup_path}")
        return backup_path

    except Exception as e:
        print(f"⚠️  Warning: Could not create backup: {e}")
        return None


def install_skill_update(
    skill_name: str,
    download_url: Optional[str] = None,
    github_url: Optional[str] = None,
    skills_dir: Optional[Path] = None,
    api_key: Optional[str] = None,
    backup: bool = True,
) -> bool:
    """
    Download and install skill update.

    Args:
        skill_name: Name of the skill to update
        download_url: Direct download URL (optional)
        github_url: GitHub repository URL (for inferring download URL)
        skills_dir: Skills directory
        api_key: API key
        backup: Whether to backup existing installation

    Returns:
        True if successful, False otherwise
    """
    if skills_dir is None:
        skills_dir = get_claude_skills_dir()

    # Find existing skill directory
    skill_dir = None
    for item in skills_dir.iterdir():
        if item.is_dir() and (item / "SKILL.md").exists():
            # Extract name from frontmatter
            import skill_diff

            frontmatter = skill_diff.extract_frontmatter(item / "SKILL.md")
            if frontmatter.get("name", "").lower() == skill_name.lower():
                skill_dir = item
                break

    if not skill_dir:
        print(f"❌ Skill '{skill_name}' not found locally")
        return False

    # Determine download URL
    if not download_url and github_url:
        download_url = infer_download_url(github_url, skill_name)

    if not download_url:
        print("❌ No download URL available")
        print("   Please provide --download-url or --github-url")
        return False

    # Create backup
    backup_path = None
    if backup:
        backup_path = backup_skill_directory(skill_dir)

    # Download to temp directory
    with tempfile.TemporaryDirectory() as temp_dir:
        temp_path = Path(temp_dir) / "downloaded.skill"
        if not download_skill_file(download_url, temp_path):
            return False

        # Verify it's a valid zip file (skill package)
        try:
            with zipfile.ZipFile(temp_path, "r") as zip_ref:
                namelist = zip_ref.namelist()
                if not namelist:
                    print("❌ Invalid skill file: empty archive")
                    return False
        except zipfile.BadZipFile:
            print("❌ Invalid skill file: not a valid zip archive")
            return False

        # Remove existing installation
        try:
            shutil.rmtree(skill_dir)
        except Exception as e:
            print(f"⚠️  Warning: Could not remove old installation: {e}")
            # Try to remove backup and restore
            if backup_path and backup_path.exists():
                shutil.rmtree(backup_path)
            return False

        # Install new version
        try:
            installed_path = install_skill(temp_path, skills_dir=skills_dir)
            print(f"✅ Successfully updated: {skill_name}")
            print(f"   Location: {installed_path}")

            # Remove backup on success
            if backup_path and backup_path.exists():
                shutil.rmtree(backup_path)
                print("🗑️  Backup removed (update successful)")

            return True

        except Exception as e:
            print(f"❌ Installation failed: {e}")

            # Restore from backup
            if backup_path and backup_path.exists():
                print(f"🔄 Restoring from backup...")
                try:
                    shutil.copytree(backup_path, skill_dir)
                    print("✅ Successfully restored from backup")
                except Exception as restore_error:
                    print(f"❌ Could not restore backup: {restore_error}")

            return False


def main():
    parser = argparse.ArgumentParser(description="Download and install skill updates from SkillsMP")
    parser.add_argument("skill_name", help="Name of the skill to update")

    download_group = parser.add_mutually_exclusive_group()
    download_group.add_argument("--download-url", help="Direct download URL")
    download_group.add_argument(
        "--github-url",
        help="GitHub repository URL (will infer download URL)",
    )

    parser.add_argument(
        "--skill-dir",
        type=Path,
        help="Custom skills directory (default: ~/.claude/skills)",
    )
    parser.add_argument("--api-key", help="API key (overrides file)")
    parser.add_argument(
        "--no-backup",
        action="store_true",
        help="Skip backup before installing",
    )
    parser.add_argument(
        "--dry-run",
        action="store_true",
        help="Show what would be done without actually installing",
    )

    args = parser.parse_args()

    try:
        if args.dry_run:
            print("🔍 Dry run mode - showing planned actions:\n")
            print(f"Skill to update: {args.skill_name}")

            if args.download_url:
                print(f"Download URL: {args.download_url}")
            elif args.github_url:
                inferred = infer_download_url(args.github_url, args.skill_name)
                print(f"GitHub URL: {args.github_url}")
                print(f"Inferred download URL: {inferred}")
            else:
                print("❌ No download source specified")
                sys.exit(1)

            backup_msg = "Backup: " + ("No (disabled)" if args.no_backup else "Yes")
            print(backup_msg)
            print("\n✅ Dry run complete - no changes made")
            return

        # Perform actual installation
        success = install_skill_update(
            skill_name=args.skill_name,
            download_url=args.download_url,
            github_url=args.github_url,
            skills_dir=args.skill_dir,
            api_key=args.api_key,
            backup=not args.no_backup,
        )

        sys.exit(0 if success else 1)

    except SkillsMPError as e:
        print(f"❌ Error: {e}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()