peekme 0.3.5

Select text in Claude Code, Codex CLI or GitHub Copilot CLI output and get a short explanation right under it, inside the terminal
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

//! The agent CLIs peekme knows. What differs between them is reached through
//! here: the command users type, which invocations open an interactive
//! screen, and how the explainer should describe the screen.

use std::path::Path;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Agent {
    Claude,
    Codex,
    Copilot,
}

impl Agent {
    pub const ALL: [Agent; 3] = [Agent::Claude, Agent::Codex, Agent::Copilot];

    /// The command users type.
    pub fn command(self) -> &'static str {
        match self {
            Agent::Claude => "claude",
            Agent::Codex => "codex",
            Agent::Copilot => "copilot",
        }
    }

    /// Product name, for messages.
    pub fn name(self) -> &'static str {
        match self {
            Agent::Claude => "Claude Code",
            Agent::Codex => "Codex",
            Agent::Copilot => "GitHub Copilot CLI",
        }
    }

    /// Short name, for "Claude: 3 updates waiting".
    pub fn short(self) -> &'static str {
        match self {
            Agent::Claude => "Claude",
            Agent::Codex => "Codex",
            Agent::Copilot => "Copilot",
        }
    }

    pub fn install_hint(self) -> &'static str {
        match self {
            Agent::Claude => "npm i -g @anthropic-ai/claude-code",
            Agent::Codex => "npm i -g @openai/codex",
            Agent::Copilot => "npm i -g @github/copilot",
        }
    }

    /// "Claude Code, Codex and GitHub Copilot CLI", for messages.
    pub fn all_names() -> String {
        list(Agent::ALL.iter().map(|a| a.name().to_string()).collect())
    }

    /// "`claude`, `codex` or `copilot`", for messages.
    pub fn all_commands(last: &str) -> String {
        let mut v: Vec<String> = Agent::ALL
            .iter()
            .map(|a| format!("`{}`", a.command()))
            .collect();
        let tail = v.pop().unwrap_or_default();
        format!("{} {last} {tail}", v.join(", "))
    }

    /// The agent a program path runs, by its file name.
    pub fn from_program(program: &str) -> Option<Agent> {
        let name = Path::new(program).file_name()?.to_str()?;
        Agent::ALL.into_iter().find(|a| a.command() == name)
    }

    /// Whether `<command> <args>` opens the agent's interactive screen, where
    /// peeking helps. Everything else runs the agent directly.
    pub fn is_interactive(self, args: &[String]) -> bool {
        match self {
            Agent::Claude => crate::claude::cli::is_interactive(args),
            Agent::Codex => crate::codex::cli::is_interactive(args),
            Agent::Copilot => crate::copilot::cli::is_interactive(args),
        }
    }

    /// One paragraph telling the explainer what the screen is.
    pub fn environment(self, cwd: &str) -> String {
        let (who, what) = match self {
            Agent::Codex => (
                "Codex CLI, OpenAI's coding agent for the terminal",
                "command output, or the Codex CLI interface itself",
            ),
            Agent::Claude => (
                "Claude Code, Anthropic's coding agent for the terminal",
                "tool calls and their output, or the Claude Code interface itself",
            ),
            Agent::Copilot => (
                "GitHub Copilot CLI, GitHub's coding agent for the terminal",
                "tool calls and their output, or the Copilot CLI interface itself",
            ),
        };
        format!(
            "<environment>\nThe user is working in {who}, in the directory {cwd}. Text on their \
             screen is the assistant's answers, the user's messages, {what} (tips, status lines, \
             prompts).\n</environment>\n\n"
        )
    }
}

fn list(mut v: Vec<String>) -> String {
    let last = v.pop().unwrap_or_default();
    if v.is_empty() {
        last
    } else {
        format!("{} and {last}", v.join(", "))
    }
}

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

    #[test]
    fn agent_from_program() {
        assert_eq!(Agent::from_program("codex"), Some(Agent::Codex));
        assert_eq!(Agent::from_program("/usr/bin/claude"), Some(Agent::Claude));
        assert_eq!(Agent::from_program("copilot"), Some(Agent::Copilot));
        assert_eq!(Agent::from_program("htop"), None);
        assert_eq!(
            Agent::all_names(),
            "Claude Code, Codex and GitHub Copilot CLI"
        );
        assert_eq!(Agent::all_commands("or"), "`claude`, `codex` or `copilot`");
    }
}