Importing Hermes/OpenClaw Skills

from praisonaiagents import Agent
from praisonaiagents.skills import discover_skills

# Discover skills from custom directory
skills = discover_skills(["/path/to/hermes-skills"])

agent = Agent(
    name="SkillAgent",
    instructions="Use imported skills to help users",
    skills=skills
)

agent.start("Process this data using available skills")

from praisonaiagents import Agent
from praisonaiagents.skills import validate, load_skill

# Validate skill before import
skill_path = "/path/to/hermes-skills/data-processor"
errors = validate(skill_path)

if not errors:
    skill = load_skill("data-processor", ["/path/to/hermes-skills"])
    agent = Agent(
        name="ValidatedAgent",
        instructions="Use validated skills only",
        skills=[skill] if skill else []
    )
else:
    print(f"Skill validation failed: {errors}")

from pathlib import Path

def validate_encoding(skill_path: str) -> bool:
    """Validate all files in skill directory are UTF-8 encoded."""
    skill_dir = Path(skill_path)
    
    for file_path in skill_dir.rglob("*.md"):
        try:
            file_path.read_text(encoding='utf-8')
        except UnicodeDecodeError:
            print(f"Invalid encoding in {file_path}")
            return False
    
    return True

import yaml
from pathlib import Path

def lint_frontmatter(skill_path: str) -> list:
    """Lint SKILL.md frontmatter for compatibility."""
    skill_md = Path(skill_path) / "SKILL.md"
    content = skill_md.read_text()
    
    if not content.startswith('---'):
        return ["Missing YAML frontmatter"]
    
    # Extract frontmatter
    parts = content.split('---', 2)
    if len(parts) < 3:
        return ["Malformed frontmatter"]
    
    try:
        frontmatter = yaml.safe_load(parts[1])
        required_keys = ['name', 'description']
        missing = [key for key in required_keys if key not in frontmatter]
        return [f"Missing required key: {key}" for key in missing]
    except yaml.YAMLError as e:
        return [f"Invalid YAML: {e}"]

import shutil
from pathlib import Path

def import_skill(source_path: str, target_dir: str = None) -> str:
    """Import Hermes/OpenClaw skill to PraisonAI discovery root."""
    source = Path(source_path)
    
    # Default to project-level skills directory
    if target_dir is None:
        target_dir = Path.cwd() / ".praisonai" / "skills"
    else:
        target_dir = Path(target_dir)
    
    target_dir.mkdir(parents=True, exist_ok=True)
    destination = target_dir / source.name
    
    # Handle name conflicts
    counter = 1
    while destination.exists():
        destination = target_dir / f"{source.name}-{counter}"
        counter += 1
    
    shutil.copytree(source, destination)
    return str(destination)

from praisonaiagents.skills import discover_skills

def test_discovery(skills_dir: str) -> bool:
    """Test if imported skills are discoverable."""
    skills = discover_skills([skills_dir])
    
    if not skills:
        print("No skills discovered")
        return False
    
    for skill in skills:
        print(f"✓ Discovered: {skill.name} - {skill.description}")
    
    return True

import re
from pathlib import Path

def security_review(skill_path: str) -> list:
    """Review skill for security issues."""
    issues = []
    skill_dir = Path(skill_path)
    
    # Check for hardcoded secrets
    secret_patterns = [
        r'api[_-]?key\s*=\s*["\'][^"\']+["\']',
        r'password\s*=\s*["\'][^"\']+["\']',
        r'token\s*=\s*["\'][^"\']+["\']'
    ]
    
    for file_path in skill_dir.rglob("*"):
        if file_path.is_file() and file_path.suffix in ['.md', '.py', '.txt']:
            content = file_path.read_text()
            for pattern in secret_patterns:
                if re.search(pattern, content, re.IGNORECASE):
                    issues.append(f"Potential secret in {file_path}")
    
    return issues