skillflag 0.1.0

Rust implementation of the Skillflag producer library/CLI and the skill-install companion CLI.
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
132
133
134
135
136
137
138

//! End-to-end tests running the compiled binaries.

mod support;

use std::io::Write;
use std::process::{Command, Stdio};

use support::{assert_tree_equal, fixtures_root, TempDir};

const PRODUCER_BIN: &str = env!("CARGO_BIN_EXE_skillflag");
const INSTALLER_BIN: &str = env!("CARGO_BIN_EXE_skill-install");

#[test]
fn skills_root_env_serves_fixtures_and_excludes_bundled_skill() {
    let output = Command::new(PRODUCER_BIN)
        .args(["--skill", "list"])
        .env("SKILLFLAG_SKILLS_ROOT", fixtures_root())
        .output()
        .unwrap();
    assert!(output.status.success());
    assert_eq!(
        String::from_utf8(output.stdout).unwrap(),
        "alpha\tAlpha test skill\nbeta\tBeta test skill\n"
    );
}

#[test]
fn skills_root_env_accepts_multiple_paths() {
    let extra = TempDir::new();
    support::write_skill_dir(extra.path(), "zzz", "zzz");
    let joined = std::env::join_paths([fixtures_root().as_path(), extra.path()]).unwrap();
    let output = Command::new(PRODUCER_BIN)
        .args(["--skill", "list"])
        .env("SKILLFLAG_SKILLS_ROOT", joined)
        .output()
        .unwrap();
    assert!(output.status.success());
    assert_eq!(
        String::from_utf8(output.stdout).unwrap(),
        "alpha\tAlpha test skill\nbeta\tBeta test skill\nzzz\tzzz skill\n"
    );
}

#[test]
fn without_skills_root_env_only_the_bundled_skill_is_listed() {
    let output = Command::new(PRODUCER_BIN)
        .args(["--skill", "list"])
        .env_remove("SKILLFLAG_SKILLS_ROOT")
        .output()
        .unwrap();
    assert!(output.status.success());
    let stdout = String::from_utf8(output.stdout).unwrap();
    assert!(stdout.starts_with("skillflag\t"), "stdout: {stdout}");
    assert_eq!(stdout.lines().count(), 1);
}

#[test]
fn direct_action_form_works() {
    let output = Command::new(PRODUCER_BIN)
        .args(["list", "--json"])
        .env("SKILLFLAG_SKILLS_ROOT", fixtures_root())
        .output()
        .unwrap();
    assert!(output.status.success());
    let stdout = String::from_utf8(output.stdout).unwrap();
    assert!(stdout.starts_with("{\"skillflag_version\":\"0.1\",\"skills\":[{\"id\":\"alpha\""));
    assert!(!stdout.ends_with('\n'));
}

#[test]
fn export_pipes_into_installer_round_trip() {
    let cwd = TempDir::new();

    let producer = Command::new(PRODUCER_BIN)
        .args(["--skill", "export", "alpha"])
        .env("SKILLFLAG_SKILLS_ROOT", fixtures_root())
        .output()
        .unwrap();
    assert!(producer.status.success());
    let tar = producer.stdout;
    assert_eq!(tar.len() % 512, 0);

    let mut installer = Command::new(INSTALLER_BIN)
        .args(["--agent", "codex", "--scope", "repo"])
        .current_dir(cwd.path())
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()
        .unwrap();
    installer.stdin.take().unwrap().write_all(&tar).unwrap();
    let result = installer.wait_with_output().unwrap();
    let stderr = String::from_utf8(result.stderr).unwrap();
    assert!(result.status.success(), "stderr: {stderr}");
    assert!(stderr.starts_with("Installed alpha to "));

    // No .git in the temp dir, so the repo root falls back to cwd.
    let dest = cwd.path().join(".codex").join("skills").join("alpha");
    assert_tree_equal(&fixtures_root().join("alpha"), &dest);
}

#[test]
fn producer_install_subcommand_routes_to_installer() {
    let cwd = TempDir::new();
    let source = fixtures_root().join("alpha");
    let output = Command::new(PRODUCER_BIN)
        .args([
            "install",
            source.to_str().unwrap(),
            "--agent",
            "codex",
            "--scope",
            "cwd",
        ])
        .current_dir(cwd.path())
        .stdin(Stdio::null())
        .output()
        .unwrap();
    let stderr = String::from_utf8(output.stderr).unwrap();
    assert!(output.status.success(), "stderr: {stderr}");
    let dest = cwd.path().join(".codex").join("skills").join("alpha");
    assert_tree_equal(&source, &dest);
}

#[test]
fn unknown_id_exit_code_from_binary() {
    let output = Command::new(PRODUCER_BIN)
        .args(["--skill", "export", "nope"])
        .env("SKILLFLAG_SKILLS_ROOT", fixtures_root())
        .output()
        .unwrap();
    assert_eq!(output.status.code(), Some(1));
    assert_eq!(
        String::from_utf8(output.stderr).unwrap(),
        "Skill not found: nope\n"
    );
    assert!(output.stdout.is_empty());
}