skm-cli 0.1.0

Developer CLI for Agent Skills - validate, test, optimize, and serve
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

//! Index command: build/rebuild embedding index.

use clap::Args;
use std::path::PathBuf;

#[derive(Args)]
pub struct IndexArgs {
    /// Skill directories
    #[arg(short, long, default_value = ".")]
    skills: Vec<PathBuf>,

    /// Output index file
    #[arg(short, long, default_value = ".skm-index.bin")]
    output: PathBuf,

    /// Embedding model (bge-m3, minilm)
    #[arg(short, long, default_value = "minilm")]
    model: String,

    /// Force rebuild even if cache is valid
    #[arg(short, long)]
    force: bool,
}

pub async fn index(args: IndexArgs) -> anyhow::Result<()> {
    println!("Building embedding index...");
    println!("  Skills: {:?}", args.skills);
    println!("  Output: {:?}", args.output);
    println!("  Model: {}", args.model);
    println!("  Force: {}", args.force);
    println!();

    // Check if we have embedding features
    #[cfg(not(any(feature = "embed-bge-m3", feature = "embed-minilm")))]
    {
        println!("Warning: No embedding providers compiled in.");
        println!("Rebuild with --features embed-bge-m3 or --features embed-minilm");
        return Ok(());
    }

    #[cfg(any(feature = "embed-bge-m3", feature = "embed-minilm"))]
    {
        use skm_core::SkillRegistry;
        use skm_embed::{ComponentWeights, EmbeddingIndex, EmbeddingProvider};

        let registry = SkillRegistry::new(&args.skills).await?;
        println!("Found {} skills", registry.len().await);

        // Create provider based on model
        let provider: Box<dyn EmbeddingProvider> = match args.model.as_str() {
            #[cfg(feature = "embed-bge-m3")]
            "bge-m3" | "bge" => {
                println!("Loading BGE-M3 model...");
                Box::new(skm_embed::BgeM3Provider::new()?)
            }
            #[cfg(feature = "embed-minilm")]
            "minilm" | "mini" => {
                println!("Loading MiniLM model...");
                Box::new(skm_embed::MiniLmProvider::new()?)
            }
            other => {
                anyhow::bail!("Unknown model: {}. Use 'bge-m3' or 'minilm'", other);
            }
        };

        println!("Building index (this may take a while)...");
        let index = EmbeddingIndex::build(
            &registry,
            provider.as_ref(),
            ComponentWeights::default(),
        )
        .await?;

        println!("Saving index to {:?}...", args.output);
        index.save(&args.output)?;

        println!("✓ Index built successfully ({} skills)", index.len());
    }

    Ok(())
}