Skill Registration

use fastskill::{SkillDefinition, SkillId};

let mut skill = SkillDefinition::new(
    SkillId::new("text-processor".to_string())?,
    "Text Processing Suite".to_string(),
    "Comprehensive text processing capabilities including extraction, analysis, and transformation".to_string(),
    "1.0.0".to_string(),
);

skill.author = Some("FastSkill Team".to_string());
skill.tags = vec![
    "text".to_string(),
    "nlp".to_string(),
    "analysis".to_string(),
    "extraction".to_string(),
    "transformation".to_string(),
];
skill.capabilities = vec![
    "text_extraction".to_string(),
    "text_analysis".to_string(),
    "sentiment_analysis".to_string(),
    "keyword_extraction".to_string(),
    "text_transformation".to_string(),
];
skill.skill_file = std::path::PathBuf::from("text-processor/SKILL.md");
skill.enabled = true;
skill.timeout = Some(30);
skill.dependencies = Some(vec![
    "nltk".to_string(),
    "spacy".to_string(),
]);

use fastskill::{FastSkillService, ServiceConfig};
use std::path::PathBuf;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = ServiceConfig {
        skill_storage_path: PathBuf::from("./skills"),
        ..Default::default()
    };

    let mut service = FastSkillService::new(config).await?;
    service.initialize().await?;

    // Register the skill (using skill from previous step)
    let skill_id = service.skill_manager().register_skill(skill).await?;
    println!("✅ Skill registered with ID: {}", skill_id);

    // Verify registration
    let skills = service.skill_manager().list_skills(None).await?;
    println!("📋 Total skills: {}", skills.len());

    service.shutdown().await?;
    Ok(())
}

use fastskill::{FastSkillService, ServiceConfig, SkillId, SkillUpdate};
use std::path::PathBuf;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = ServiceConfig {
        skill_storage_path: PathBuf::from("./skills"),
        ..Default::default()
    };

    let mut service = FastSkillService::new(config).await?;
    service.initialize().await?;

    let skill_id = SkillId::new("text-processor".to_string())?;

    // Update skill definition
    let updates = SkillUpdate {
        name: Some("Advanced Text Processing Suite".to_string()),
        description: Some("Enhanced text processing with AI-powered analysis".to_string()),
        version: Some("1.1.0".to_string()),
        tags: Some(vec![
            "text".to_string(),
            "nlp".to_string(),
            "analysis".to_string(),
            "ai".to_string(),
        ]),
        capabilities: Some(vec![
            "text_extraction".to_string(),
            "text_analysis".to_string(),
            "ai_analysis".to_string(),
        ]),
        ..Default::default()
    };

    // Update the skill
    service.skill_manager()
        .update_skill(&skill_id, updates)
        .await?;

    println!("✅ Skill updated successfully");

    service.shutdown().await?;
    Ok(())
}

// Auto-discovery happens automatically when service initializes
// Skills are discovered from the skill_storage_path directory
// The service scans for SKILL.md files during initialization

use fastskill::{FastSkillService, ServiceConfig, SkillDefinition, SkillId};
use std::path::PathBuf;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = ServiceConfig {
        skill_storage_path: PathBuf::from("./skills"),
        ..Default::default()
    };

    let mut service = FastSkillService::new(config).await?;
    service.initialize().await?;

    // Create skill definition
    let skill = SkillDefinition::new(
        SkillId::new("my-skill".to_string())?,
        "My Skill".to_string(),
        "A test skill".to_string(),
        "1.0.0".to_string(),
    );

    // Validation happens automatically during registration
    // Register the skill (will validate internally)
    match service.skill_manager().register_skill(skill).await {
        Ok(skill_id) => {
            println!("✅ Skill definition is valid");
            println!("✅ Registered: {}", skill_id);
        }
        Err(e) => {
            eprintln!("❌ Validation/registration failed: {}", e);
            // Fix the issues before registering
        }
    }

    service.shutdown().await?;
    Ok(())
}

use fastskill::{FastSkillService, ServiceConfig, SkillDefinition, SkillId};
use std::path::PathBuf;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = ServiceConfig {
        skill_storage_path: PathBuf::from("./skills"),
        ..Default::default()
    };

    let mut service = FastSkillService::new(config).await?;
    service.initialize().await?;

    // Define skills to validate and register
    let skills_to_validate = vec![
        SkillDefinition::new(
            SkillId::new("skill1".to_string())?,
            "Skill 1".to_string(),
            "First skill".to_string(),
            "1.0.0".to_string(),
        ),
        SkillDefinition::new(
            SkillId::new("skill2".to_string())?,
            "Skill 2".to_string(),
            "Second skill".to_string(),
            "1.0.0".to_string(),
        ),
    ];

    let mut valid_count = 0;
    let mut invalid_count = 0;

    for skill in skills_to_validate {
        match service.skill_manager().register_skill(skill).await {
            Ok(_) => {
                valid_count += 1;
            }
            Err(_) => {
                invalid_count += 1;
            }
        }
    }

    println!("✅ Valid skills: {}", valid_count);
    println!("❌ Invalid skills: {}", invalid_count);

    service.shutdown().await?;
    Ok(())
}