smackdebt 0.3.0

Find costly code debt and see whether your changes make it better
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

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

use clap::ValueEnum;
use serde::{Deserialize, Serialize};

#[derive(Clone, Copy, Debug, Eq, PartialEq, ValueEnum, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub(crate) enum Agent {
    Codex,
    ClaudeCode,
    Cursor,
    Copilot,
    Gemini,
}

impl Agent {
    pub(crate) const ALL: [Self; 5] = [
        Self::Codex,
        Self::ClaudeCode,
        Self::Cursor,
        Self::Copilot,
        Self::Gemini,
    ];

    pub(crate) fn name(self) -> &'static str {
        match self {
            Self::Codex => "codex",
            Self::ClaudeCode => "claude-code",
            Self::Cursor => "cursor",
            Self::Copilot => "copilot",
            Self::Gemini => "gemini",
        }
    }

    pub(crate) fn label(self) -> &'static str {
        match self {
            Self::Codex => "Codex",
            Self::ClaudeCode => "Claude Code",
            Self::Cursor => "Cursor",
            Self::Copilot => "GitHub Copilot",
            Self::Gemini => "Gemini CLI",
        }
    }

    pub(crate) fn directory(
        self,
        home: &Path,
        codex: Option<PathBuf>,
        claude: Option<PathBuf>,
    ) -> PathBuf {
        let root = match self {
            Self::Codex => codex.unwrap_or_else(|| home.join(".codex")),
            Self::ClaudeCode => claude.unwrap_or_else(|| home.join(".claude")),
            Self::Cursor => home.join(".cursor"),
            Self::Copilot => home.join(".copilot"),
            Self::Gemini => home.join(".gemini"),
        };
        root.join("skills/smackdebt")
    }
}

#[derive(Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct Selection {
    pub(crate) selected: Vec<Agent>,
    pub(crate) installations: Vec<Installation>,
    #[serde(default)]
    pub(crate) experimental_hooks: Vec<Agent>,
}

#[derive(Clone, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct Installation {
    pub(crate) agent: Agent,
    pub(crate) directory: PathBuf,
}

impl Selection {
    pub(crate) fn remembered(&self, agent: Agent) -> Option<&Installation> {
        self.installations
            .iter()
            .find(|install| install.agent == agent)
    }

    pub(crate) fn remember(&mut self, install: Installation) -> Result<(), String> {
        if let Some(other) = self
            .installations
            .iter()
            .find(|saved| saved.agent != install.agent && saved.directory == install.directory)
        {
            return Err(format!(
                "skill destination is already used by {}",
                other.agent.name()
            ));
        }
        if let Some(previous) = self.remembered(install.agent) {
            if previous.directory != install.directory {
                return Err(format!(
                    "{} is installed at {}; uninstall it before changing its destination",
                    install.agent.name(),
                    previous.directory.display()
                ));
            }
        } else {
            self.installations.push(install);
        }
        Ok(())
    }
}