claude-profiles 0.4.1

Launch claude with only the plugins, skills, and MCP servers a profile defines
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

use std::path::PathBuf;

pub struct Paths {
    pub home: PathBuf,
}

impl Paths {
    pub fn from_home(home: PathBuf) -> Paths {
        Paths { home }
    }

    pub fn detect() -> anyhow::Result<Paths> {
        let home = std::env::var_os("HOME")
            .map(PathBuf::from)
            .ok_or_else(|| anyhow::anyhow!("HOME is not set"))?;
        Ok(Paths::from_home(home))
    }

    pub fn user_profiles_dir(&self) -> PathBuf {
        self.home.join(".claude-profiles")
    }

    pub fn claude_skills_dir(&self) -> PathBuf {
        self.home.join(".claude").join("skills")
    }

    // Claude Code's own global settings file — used by `statusline install` to add a statusLine entry.
    pub fn claude_settings_path(&self) -> PathBuf {
        self.home.join(".claude").join("settings.json")
    }

    pub fn statusline_backups_dir(&self) -> PathBuf {
        self.user_profiles_dir().join("statusline-backups")
    }

    // Phase 2/3: profile locking (concurrent-launch guard) will use this.
    #[allow(dead_code)]
    pub fn locks_dir(&self) -> PathBuf {
        self.user_profiles_dir().join("locks")
    }

    pub fn index_cache_dir(&self) -> PathBuf {
        self.user_profiles_dir().join(".index-cache")
    }

    pub fn index_file(&self) -> PathBuf {
        self.index_cache_dir().join("index.json")
    }

    pub fn index_repos_dir(&self) -> PathBuf {
        self.index_cache_dir().join("repos")
    }

    pub fn marketplaces_seed_file(&self) -> PathBuf {
        self.user_profiles_dir().join("marketplaces.txt")
    }

    pub fn store_dir(&self) -> PathBuf {
        self.user_profiles_dir().join("store")
    }

    pub fn marketplace_clone_dir(&self, name: &str) -> PathBuf {
        self.store_dir().join("marketplaces").join(name)
    }

    pub fn external_marketplace_dir(&self, owner: &str, repo: &str) -> PathBuf {
        self.store_dir().join("marketplaces").join("_external").join(format!("{owner}--{repo}"))
    }

    pub fn profile_vendor_dir(&self, profile_key: &str) -> PathBuf {
        self.store_dir().join(profile_key).join("vendor")
    }
}

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

    #[test]
    fn derives_paths_from_home() {
        let p = Paths::from_home(PathBuf::from("/h"));
        assert_eq!(p.user_profiles_dir(), PathBuf::from("/h/.claude-profiles"));
        assert_eq!(p.claude_skills_dir(), PathBuf::from("/h/.claude/skills"));
        assert_eq!(p.claude_settings_path(), PathBuf::from("/h/.claude/settings.json"));
        assert_eq!(p.locks_dir(), PathBuf::from("/h/.claude-profiles/locks"));
    }

    #[test]
    fn derives_index_paths_from_home() {
        let p = Paths::from_home(PathBuf::from("/h"));
        assert_eq!(p.index_cache_dir(), PathBuf::from("/h/.claude-profiles/.index-cache"));
        assert_eq!(p.index_file(), PathBuf::from("/h/.claude-profiles/.index-cache/index.json"));
        assert_eq!(p.index_repos_dir(), PathBuf::from("/h/.claude-profiles/.index-cache/repos"));
        assert_eq!(p.marketplaces_seed_file(), PathBuf::from("/h/.claude-profiles/marketplaces.txt"));
    }

    #[test]
    fn derives_store_and_vendor_paths() {
        let p = Paths::from_home(PathBuf::from("/h"));
        assert_eq!(p.store_dir(), PathBuf::from("/h/.claude-profiles/store"));
        assert_eq!(
            p.marketplace_clone_dir("superpowers-marketplace"),
            PathBuf::from("/h/.claude-profiles/store/marketplaces/superpowers-marketplace")
        );
        assert_eq!(
            p.external_marketplace_dir("fuzzyalej", "openpowers"),
            PathBuf::from("/h/.claude-profiles/store/marketplaces/_external/fuzzyalej--openpowers")
        );
        assert_eq!(
            p.profile_vendor_dir("rust-developer"),
            PathBuf::from("/h/.claude-profiles/store/rust-developer/vendor")
        );
    }

    #[test]
    fn derives_statusline_backups_dir() {
        let p = Paths::from_home(PathBuf::from("/h"));
        assert_eq!(
            p.statusline_backups_dir(),
            PathBuf::from("/h/.claude-profiles/statusline-backups")
        );
    }
}