jarvy 0.4.0

Jarvy is a fast, cross-platform CLI that installs and manages developer tools across macOS and Linux.
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
139
140
141

//! `[skills]` configuration schema.

use serde::{Deserialize, Serialize};
use std::collections::HashMap;

use crate::ai_hooks::ConfigOrigin;

#[derive(Clone, Debug, Default, Deserialize, Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct SkillsConfig {
    /// Auto-install skills during `jarvy setup` (default true). When
    /// false, the block is parsed but no installation happens until
    /// `jarvy skills install` runs manually.
    #[serde(default = "default_true")]
    pub auto_install: bool,

    /// Which agents to install skills for. Empty = auto-detect every
    /// AI agent installed on disk. Use `["claude-code", "cursor"]` to
    /// narrow.
    #[serde(default)]
    pub agents: Vec<String>,

    /// Skill entries by name. Each value is either a bare version
    /// string or a detailed `{ version = "...", agents = [...] }`
    /// table for per-skill agent narrowing.
    #[serde(default)]
    pub install: HashMap<String, SkillEntry>,

    /// Library manifests to consult for skill definitions (PRD-054).
    /// Local-origin only — remote-fetched configs are refused at
    /// install time by `library_registry::check_origin`.
    #[serde(default)]
    pub library_sources: Vec<crate::library_registry::LibrarySource>,

    /// Origin tag set by the config loader; not serialized.
    #[serde(skip)]
    pub origin: ConfigOrigin,
}

impl SkillsConfig {
    #[allow(dead_code)] // Public API; reserved for setup-phase short-circuit
    pub fn is_empty(&self) -> bool {
        self.install.is_empty()
    }
}

#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(untagged)]
pub enum SkillEntry {
    /// `myorg-code-review = "2.1.0"` — bare version string. `"latest"`
    /// pulls whatever the library_source currently advertises.
    Version(String),
    /// Inline table with optional per-skill agent narrowing.
    Detailed {
        version: String,
        #[serde(default)]
        agents: Vec<String>,
    },
}

impl SkillEntry {
    pub fn version(&self) -> &str {
        match self {
            SkillEntry::Version(v) => v,
            SkillEntry::Detailed { version, .. } => version,
        }
    }

    /// Per-skill agent narrowing. Empty list = "all configured agents".
    pub fn agents(&self) -> &[String] {
        match self {
            SkillEntry::Version(_) => &[],
            SkillEntry::Detailed { agents, .. } => agents,
        }
    }
}

fn default_true() -> bool {
    true
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn defaults_via_serde() {
        let cfg: SkillsConfig = toml::from_str("").unwrap();
        assert!(cfg.auto_install);
        assert!(cfg.agents.is_empty());
        assert!(cfg.install.is_empty());
        assert!(cfg.library_sources.is_empty());
    }

    #[test]
    fn parses_bare_version() {
        let toml_str = r#"
[install]
myorg-code-review = "2.1.0"
"#;
        let cfg: SkillsConfig = toml::from_str(toml_str).unwrap();
        assert_eq!(cfg.install.len(), 1);
        match &cfg.install["myorg-code-review"] {
            SkillEntry::Version(v) => assert_eq!(v, "2.1.0"),
            other => panic!("expected Version, got {other:?}"),
        }
    }

    #[test]
    fn parses_detailed_with_agents() {
        let toml_str = r#"
[install]
myorg-code-review = { version = "2.1.0", agents = ["claude-code"] }
"#;
        let cfg: SkillsConfig = toml::from_str(toml_str).unwrap();
        match &cfg.install["myorg-code-review"] {
            SkillEntry::Detailed { version, agents } => {
                assert_eq!(version, "2.1.0");
                assert_eq!(agents, &["claude-code"]);
            }
            other => panic!("expected Detailed, got {other:?}"),
        }
    }

    #[test]
    fn parses_library_sources() {
        let toml_str = r#"
[[library_sources]]
url = "https://cdn.example.com/manifest.json"
"#;
        let cfg: SkillsConfig = toml::from_str(toml_str).unwrap();
        assert_eq!(cfg.library_sources.len(), 1);
    }

    #[test]
    fn rejects_unknown_top_level_field() {
        let toml_str = "garbage = true";
        let err = toml::from_str::<SkillsConfig>(toml_str).unwrap_err();
        assert!(format!("{err}").contains("garbage"));
    }
}