skillrt 0.1.0

A runtime and spec for executable markdown skills consumed by AI agents.
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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//! `skill` - CLI for the skillrt runtime.
//!
//! Run `skill help` for command reference.

use anyhow::{Context, Result};
use clap::{Parser, Subcommand};
use skillrt::{parser, registry};
use std::path::PathBuf;

#[derive(Parser)]
#[command(name = "skill")]
#[command(version, about = "Runtime for executable markdown skills", long_about = None)]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    /// Validate a SKILL.md against the spec.
    Validate {
        /// Path to a SKILL.md file.
        path: PathBuf,
    },

    /// Show metadata for a SKILL.md (frontmatter parsed + body length).
    Info { path: PathBuf },

    /// List locally installed skills.
    List,

    /// Install a skill from a local path.
    Install { path: PathBuf },

    /// Run a skill (v0.1: prints the skill body; execution lands in v0.2).
    Run {
        /// Skill name or path to a SKILL.md.
        target: String,

        /// Inputs as JSON.
        #[arg(long, default_value = "{}")]
        inputs: String,
    },

    /// Print the path to the local skill store.
    Where,
}

fn main() -> Result<()> {
    let cli = Cli::parse();

    match cli.command {
        Commands::Validate { path } => {
            let src = std::fs::read_to_string(&path)
                .with_context(|| format!("reading {}", path.display()))?;
            let skill = parser::parse(&src, Some(path.clone()))?;
            match &skill.kind {
                skillrt::SkillKind::Prose => {
                    println!("ok (prose, {} bytes)", skill.body.markdown.len());
                }
                skillrt::SkillKind::Structured => {
                    let fm = skill.frontmatter.as_ref().unwrap();
                    println!("ok (structured) {}@{}", fm.name, fm.version);
                }
            }
        }

        Commands::Info { path } => {
            let src = std::fs::read_to_string(&path)?;
            let skill = parser::parse(&src, Some(path))?;
            match skill.kind {
                skillrt::SkillKind::Prose => {
                    println!("kind: prose");
                    println!("body-bytes: {}", skill.body.markdown.len());
                }
                skillrt::SkillKind::Structured => {
                    let fm = skill.frontmatter.unwrap();
                    println!("kind: structured");
                    println!("name: {}", fm.name);
                    println!("version: {}", fm.version);
                    println!("description: {}", fm.description);
                    println!("authors: {:?}", fm.authors);
                    println!("license: {}", fm.license);
                    println!("inputs: {}", fm.inputs.len());
                    println!("tags: {:?}", fm.tags);
                }
            }
        }

        Commands::List => {
            let skills = registry::list()?;
            if skills.is_empty() {
                println!("(no skills installed; try `skill install <path>`)");
            } else {
                for s in skills {
                    if let Some(fm) = s.frontmatter {
                        println!("{}@{}  {}", fm.name, fm.version, fm.description);
                    }
                }
            }
        }

        Commands::Install { path } => {
            let dest = registry::install_from_path(&path)?;
            println!("installed to {}", dest.display());
        }

        Commands::Run {
            target,
            inputs: _inputs,
        } => {
            let skill = if let Ok(p) = PathBuf::from(&target).canonicalize() {
                registry::load(&p)?
            } else {
                registry::list()?
                    .into_iter()
                    .find(|s| s.frontmatter.as_ref().is_some_and(|fm| fm.name == target))
                    .ok_or_else(|| anyhow::anyhow!("skill not found: {}", target))?
            };

            println!("{}", skill.body.markdown);
            eprintln!("(v0.1: printed body. Execution lands in v0.2.)");
        }

        Commands::Where => {
            println!("{}", registry::root()?.display());
        }
    }

    Ok(())
}