skillnet 0.6.0

Manage canonical AI skill stores, derived views, and calibration data for multi-phase-plan.
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

use std::{fs, path::PathBuf};

use assert_cmd::Command;
use rusqlite::Connection;
use serde_json::Value;
use tempfile::{tempdir, TempDir};

const POST_TOOL_USE_SKILL: &str = r#"{
  "tool_name": "Skill",
  "tool_input": {
    "skill": "simplify"
  },
  "tool_response": {
    "is_error": false
  }
}"#;

const SETTINGS_PRISTINE: &str = include_str!("fixtures/hook/settings-pristine.json");

struct Fixture {
    temp: TempDir,
}

impl Fixture {
    fn new() -> Self {
        Self {
            temp: tempdir().unwrap(),
        }
    }

    fn settings(&self) -> PathBuf {
        self.temp.path().join("settings.json")
    }

    fn data_dir(&self) -> PathBuf {
        self.temp.path().join("data")
    }

    fn db_path(&self) -> PathBuf {
        self.data_dir().join("multi-phase-plan/calibration.sqlite")
    }

    fn config_path(&self) -> PathBuf {
        self.temp.path().join("skillnet.toml")
    }

    fn command(&self) -> Command {
        let mut command = Command::cargo_bin("skillnet").unwrap();
        command.env("SKILLNET_CONFIG", self.config_path());
        command.env("skillnet_DATA_DIR", self.data_dir());
        command.env_remove("SKILLNET_DATABASE_URL");
        command.env_remove("SKILLNET_DB_URL");
        command.env_remove("DATABASE_URL");
        command.env_remove("CLAUDE_HOOK_EVENT");
        command
    }
}

#[test]
fn hook_install_ingest_and_uninstall_round_trip() {
    let fixture = Fixture::new();
    fs::write(fixture.settings(), SETTINGS_PRISTINE).unwrap();

    fixture
        .command()
        .args([
            "hook",
            "install",
            "--settings",
            fixture.settings().to_str().unwrap(),
        ])
        .assert()
        .success();

    let installed = read_json(&fixture.settings());
    assert_eq!(managed_count(&installed, "PostToolUse"), 1);
    assert_eq!(installed["permissions"]["allow"][0], "Bash(git status:*)");

    fixture
        .command()
        .env("CLAUDE_SESSION_ID", "e2e-session")
        .args(["hook", "ingest", "--strict", "--event", "PostToolUse"])
        .write_stdin(POST_TOOL_USE_SKILL)
        .assert()
        .success();

    let conn = Connection::open(fixture.db_path()).unwrap();
    let (count, skill_name, hook_event): (i64, String, String) = conn
        .query_row(
            "SELECT COUNT(*), max(skill_name), max(hook_event) FROM skill_invocations",
            [],
            |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?)),
        )
        .unwrap();
    assert_eq!(count, 1);
    assert_eq!(skill_name, "simplify");
    assert_eq!(hook_event, "PostToolUse");

    fixture
        .command()
        .args([
            "hook",
            "uninstall",
            "--settings",
            fixture.settings().to_str().unwrap(),
        ])
        .assert()
        .success();

    let uninstalled = read_json(&fixture.settings());
    assert_eq!(managed_count(&uninstalled, "PostToolUse"), 0);
    assert_eq!(uninstalled["permissions"]["allow"][0], "Bash(git status:*)");
}

fn read_json(path: &PathBuf) -> Value {
    serde_json::from_str(&fs::read_to_string(path).unwrap()).unwrap()
}

fn managed_count(settings: &Value, event: &str) -> usize {
    settings["hooks"][event]
        .as_array()
        .map(|entries| {
            entries
                .iter()
                .filter(|entry| entry["_skillnet_managed"] == true)
                .count()
        })
        .unwrap_or(0)
}