skillforge.py

#!/usr/bin/env python3
"""
SkillForge-Lifecycle CLI - AI Coding Agent Skill Lifecycle Management Engine

Usage:
    skillforge create --template <name> --name <skill-name>
    skillforge create --scratch --name <name> --file <content.md>
    skillforge validate <skill.json>
    skillforge score <skill.json>
    skillforge package <skill.json> --format <json|zip|tar.gz>
    skillforge convert <skill.json> --platform <claude-code|cursor|windsurf|copilot>
    skillforge register <skill.json>
    skillforge search [--query <text>] [--category <cat>]
    skillforge list
    skillforge version bump <skill.json> --type <major|minor|patch>
    skillforge templates
    skillforge info <skill.json>
"""

import argparse
import json
import os
import sys

# Add src to path
sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))

from src.models import Skill
from src.creator import SkillCreator
from src.validator import SkillValidator
from src.packager import SkillPackager
from src.registry import SkillRegistry
from src.converter import SkillConverter
from src.version import VersionManager


def cmd_create(args):
    """Create a new skill."""
    creator = SkillCreator(author=args.author)

    if args.template:
        skill = creator.create_from_template(
            template_name=args.template,
            skill_name=args.name,
            description=args.description or "",
            author=args.author or "",
            keywords=args.keywords.split(",") if args.keywords else None,
            version=args.version or "0.1.0"
        )
    elif args.file:
        skill = creator.create_from_existing(
            filepath=args.file,
            name=args.name,
            description=args.description or "",
            author=args.author or "",
            category=args.category or "general"
        )
    elif args.content:
        skill = creator.create_from_scratch(
            name=args.name,
            description=args.description or "",
            content=args.content,
            author=args.author or "",
            triggers=args.triggers.split(",") if args.triggers else None,
            keywords=args.keywords.split(",") if args.keywords else None,
            category=args.category or "general",
            version=args.version or "0.1.0"
        )
    else:
        print("❌ Error: Provide --template, --file, or --content")
        sys.exit(1)

    output = args.output or f"{skill.metadata.name}.json"
    skill.save(output)
    print(f"✅ Skill '{skill.metadata.name}' created successfully!")
    print(f"   Version: {skill.metadata.version}")
    print(f"   Output: {output}")
    print(f"   Tests: {len(skill.tests)}")


def cmd_validate(args):
    """Validate a skill."""
    skill = Skill.load(args.skill_file)
    validator = SkillValidator()
    result = validator.full_validation(skill)

    print(f"\n{'='*50}")
    print(f"📋 Validation Report: {result['skill_name']} v{result['version']}")
    print(f"{'='*50}")
    print(f"   Overall Score: {result['overall_score']}/100")
    print(f"   Metadata: {'✅ Valid' if result['metadata_valid'] else '❌ Invalid'}")
    print(f"   Content: {'✅ Valid' if result['content_valid'] else '❌ Invalid'}")
    print(f"   Tests: {'✅ Valid' if result['tests_valid'] else '❌ Invalid'}")
    print(f"   Security Risk: {result['security']['risk_level']}")

    if result['metadata_errors']:
        print(f"\n⚠️  Metadata Issues:")
        for e in result['metadata_errors']:
            print(f"   - {e}")

    if result['content_issues']:
        print(f"\n⚠️  Content Issues:")
        for i in result['content_issues']:
            print(f"   - {i}")

    if result['recommendations']:
        print(f"\n💡 Recommendations:")
        for r in result['recommendations']:
            print(f"   {r}")

    if args.json:
        print(f"\n📄 Full Report (JSON):")
        print(json.dumps(result, indent=2, ensure_ascii=False))


def cmd_score(args):
    """Score a skill's quality."""
    skill = Skill.load(args.skill_file)
    validator = SkillValidator()
    quality = validator.score_quality(skill)
    security = validator.scan_security(skill)

    print(f"\n{'='*50}")
    print(f"📊 Quality Score: {skill.metadata.name}")
    print(f"{'='*50}")
    print(f"   📝 Documentation: {quality.documentation_score}/100")
    print(f"   🧪 Test Coverage:  {quality.test_coverage_score}/100")
    print(f"   🔒 Security:       {quality.security_score}/100")
    print(f"   🌐 Compatibility:  {quality.compatibility_score}/100")
    print(f"   ✨ Best Practices: {quality.best_practices_score}/100")
    print(f"   ─────────────────────────────")
    print(f"   🏆 Overall Score:  {quality.overall_score}/100")
    print(f"   ⚠️  Risk Level:    {security.risk_level}")

    if security.warnings:
        print(f"\n🔒 Security Warnings:")
        for w in security.warnings:
            print(f"   - {w}")


def cmd_package(args):
    """Package a skill for distribution."""
    skill = Skill.load(args.skill_file)
    packager = SkillPackager(output_dir=args.output_dir or "./dist")

    result = packager.package(skill, format=args.format, output_path=args.output)

    print(f"✅ Skill packaged successfully!")
    print(f"   Format: {result['format']}")
    print(f"   Path: {result['path']}")
    print(f"   Size: {result['size']} bytes")
    print(f"   SHA256: {result['checksum']}")


def cmd_convert(args):
    """Convert skill to platform format."""
    skill = Skill.load(args.skill_file)
    converter = SkillConverter()

    if args.all:
        results = converter.convert_all(skill)
        for platform, info in results.items():
            print(f"\n📦 {platform.upper()}:")
            print(f"   File: {info['filepath']}")
            print(f"   Dir: {info['dir']}")
    else:
        result = converter.convert(skill, args.platform)
        output = args.output or result['filename']
        os.makedirs(os.path.dirname(output) if os.path.dirname(output) else ".", exist_ok=True)
        with open(output, "w", encoding="utf-8") as f:
            f.write(result['content'])
        print(f"✅ Converted to {args.platform} format!")
        print(f"   Output: {output}")
        print(f"   Path in project: {result['filepath']}")


def cmd_register(args):
    """Register skill in local registry."""
    registry = SkillRegistry(registry_dir=args.registry_dir)
    result = registry.import_skill(args.skill_file)

    if result.get("status") == "error":
        print(f"❌ Error: {result['message']}")
    else:
        print(f"✅ Skill registered!")
        print(f"   Name: {result['name']}")
        print(f"   Version: {result['version']}")
        print(f"   Path: {result['path']}")


def cmd_search(args):
    """Search skills in registry."""
    registry = SkillRegistry(registry_dir=args.registry_dir)
    results = registry.search(
        query=args.query or "",
        category=args.category or "",
        platform=args.platform or "",
        keyword=args.keyword or "",
        sort_by=args.sort or "name"
    )

    if not results:
        print("🔍 No skills found.")
        return

    print(f"\n🔍 Found {len(results)} skill(s):\n")
    for r in results:
        print(f"   📦 {r['name']} v{r['version']}")
        print(f"      {r['description']}")
        print(f"      Score: {r['quality_score']}/100 | Risk: {r['risk_level']} | Category: {r['category']}")
        print(f"      Platforms: {', '.join(r['platforms'])}")
        print()


def cmd_list(args):
    """List all registered skills."""
    registry = SkillRegistry(registry_dir=args.registry_dir)
    skills = registry.list_skills()

    if not skills:
        print("📭 No skills registered yet.")
        print("   Use 'skillforge register <skill.json>' to add skills.")
        return

    stats = registry.get_stats()
    print(f"\n📚 Skill Registry ({stats['total_skills']} skills)\n")
    for s in skills:
        print(f"   📦 {s['name']} v{s['version']} [{s['quality_score']}pts] - {s['description'][:60]}")

    print(f"\n📂 Categories: {json.dumps(stats['categories'])}")


def cmd_version_bump(args):
    """Bump skill version."""
    skill = Skill.load(args.skill_file)
    vm = VersionManager()

    changes = []
    if args.message:
        changes = [{"type": args.change_type or "chore", "description": args.message}]

    skill, changelog = vm.version_skill(
        skill, bump_type=args.bump_type,
        changes=changes, author=args.author or ""
    )

    output = args.output or args.skill_file
    skill.save(output)

    print(f"✅ Version bumped!")
    print(f"   New version: {skill.metadata.version}")
    print(f"   Output: {output}")
    print(f"\n📝 Changelog:")
    print(changelog)


def cmd_templates(args):
    """List available templates."""
    creator = SkillCreator()
    templates = creator.list_templates()

    print(f"\n📋 Available Templates ({len(templates)}):\n")
    for t in templates:
        print(f"   🏷️  {t['name']}")
        print(f"       {t['description']}")
        print(f"       Category: {t['category']} | Triggers: {t['triggers']}")
        print()


def cmd_info(args):
    """Show detailed skill information."""
    skill = Skill.load(args.skill_file)

    print(f"\n{'='*50}")
    print(f"📦 Skill: {skill.metadata.name}")
    print(f"{'='*50}")
    print(f"   Version: {skill.metadata.version}")
    print(f"   Description: {skill.metadata.description}")
    print(f"   Author: {skill.metadata.author}")
    print(f"   License: {skill.metadata.license}")
    print(f"   Category: {skill.metadata.category}")
    print(f"   Created: {skill.metadata.created_at}")
    print(f"   Updated: {skill.metadata.updated_at}")
    print(f"\n   🌐 Platforms: {', '.join(skill.metadata.platforms)}")
    print(f"   ⚡ Triggers: {', '.join(skill.metadata.triggers) or 'None'}")
    print(f"   🏷️  Keywords: {', '.join(skill.metadata.keywords) or 'None'}")
    print(f"\n   🧪 Tests: {len(skill.tests)}")
    print(f"   🔒 Risk Level: {skill.security.risk_level}")
    print(f"   📊 Quality Score: {skill.quality.overall_score}/100")
    print(f"   📜 History: {len(skill.get_history())} entries")
    print(f"   📄 Content Length: {len(skill.content)} chars")


def main():
    parser = argparse.ArgumentParser(
        prog="skillforge",
        description="SkillForge-Lifecycle - AI Coding Agent Skill Lifecycle Management Engine",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  skillforge create --template code-review --name my-reviewer
  skillforge validate my-skill.json
  skillforge score my-skill.json
  skillforge package my-skill.json --format zip
  skillforge convert my-skill.json --platform claude-code
  skillforge register my-skill.json
  skillforge search --query "review"
  skillforge list
  skillforge version bump my-skill.json --type minor --message "Added new rules"
  skillforge templates
  skillforge info my-skill.json
        """
    )

    subparsers = parser.add_subparsers(dest="command", help="Available commands")

    # create
    p_create = subparsers.add_parser("create", help="Create a new skill")
    p_create.add_argument("--template", "-t", help="Create from template")
    p_create.add_argument("--scratch", action="store_true", help="Create from scratch")
    p_create.add_argument("--file", "-f", help="Import from existing file")
    p_create.add_argument("--content", "-c", help="Skill content string")
    p_create.add_argument("--name", "-n", required=True, help="Skill name")
    p_create.add_argument("--description", "-d", help="Skill description")
    p_create.add_argument("--author", "-a", help="Author name")
    p_create.add_argument("--keywords", "-k", help="Comma-separated keywords")
    p_create.add_argument("--triggers", help="Comma-separated trigger phrases")
    p_create.add_argument("--category", help="Skill category")
    p_create.add_argument("--version", "-v", help="Initial version")
    p_create.add_argument("--output", "-o", help="Output file path")

    # validate
    p_validate = subparsers.add_parser("validate", help="Validate a skill")
    p_validate.add_argument("skill_file", help="Path to skill JSON file")
    p_validate.add_argument("--json", action="store_true", help="Output full JSON report")

    # score
    p_score = subparsers.add_parser("score", help="Score a skill's quality")
    p_score.add_argument("skill_file", help="Path to skill JSON file")

    # package
    p_package = subparsers.add_parser("package", help="Package a skill for distribution")
    p_package.add_argument("skill_file", help="Path to skill JSON file")
    p_package.add_argument("--format", "-f", default="json",
                           choices=["json", "zip", "tar.gz"], help="Package format")
    p_package.add_argument("--output-dir", help="Output directory")
    p_package.add_argument("--output", "-o", help="Output file path")

    # convert
    p_convert = subparsers.add_parser("convert", help="Convert skill to platform format")
    p_convert.add_argument("skill_file", help="Path to skill JSON file")
    p_convert.add_argument("--platform", "-p",
                           choices=["claude-code", "cursor", "windsurf", "copilot", "generic"],
                           help="Target platform")
    p_convert.add_argument("--all", action="store_true", help="Convert to all platforms")
    p_convert.add_argument("--output", "-o", help="Output file path")

    # register
    p_register = subparsers.add_parser("register", help="Register skill in local registry")
    p_register.add_argument("skill_file", help="Path to skill JSON file")
    p_register.add_argument("--registry-dir", help="Custom registry directory")

    # search
    p_search = subparsers.add_parser("search", help="Search skills in registry")
    p_search.add_argument("--query", "-q", help="Search query")
    p_search.add_argument("--category", "-c", help="Filter by category")
    p_search.add_argument("--platform", "-p", help="Filter by platform")
    p_search.add_argument("--keyword", "-k", help="Filter by keyword")
    p_search.add_argument("--sort", "-s", default="name",
                          choices=["name", "quality", "recent", "category"],
                          help="Sort results")

    # list
    p_list = subparsers.add_parser("list", help="List all registered skills")
    p_list.add_argument("--registry-dir", help="Custom registry directory")

    # version
    p_ver = subparsers.add_parser("version", help="Version management")
    p_ver_sub = p_ver.add_subparsers(dest="version_command")
    p_bump = p_ver_sub.add_parser("bump", help="Bump skill version")
    p_bump.add_argument("skill_file", help="Path to skill JSON file")
    p_bump.add_argument("--type", "-t", default="patch",
                        choices=["major", "minor", "patch"], help="Bump type")
    p_bump.add_argument("--message", "-m", help="Change description")
    p_bump.add_argument("--change-type", help="Change type (feat/fix/docs/...)")
    p_bump.add_argument("--author", "-a", help="Author name")
    p_bump.add_argument("--output", "-o", help="Output file path")

    # templates
    subparsers.add_parser("templates", help="List available skill templates")

    # info
    p_info = subparsers.add_parser("info", help="Show skill details")
    p_info.add_argument("skill_file", help="Path to skill JSON file")

    args = parser.parse_args()

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

    commands = {
        "create": cmd_create,
        "validate": cmd_validate,
        "score": cmd_score,
        "package": cmd_package,
        "convert": cmd_convert,
        "register": cmd_register,
        "search": cmd_search,
        "list": cmd_list,
        "version": cmd_version_bump,
        "templates": cmd_templates,
        "info": cmd_info,
    }

    if args.command in commands:
        commands[args.command](args)
    else:
        parser.print_help()


if __name__ == "__main__":
    main()