jarvy 0.0.5

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

//! Get command handler - display configured tools vs installed status

use serde::Serialize;
use std::fs;

use crate::cli::OutputFormat;
use crate::config::Config;
use crate::report::{Status, ToolReport, collect_reports};

#[derive(Serialize)]
pub struct Reports {
    pub tools: Vec<ToolReport>,
}

/// Get color escape code for a tool status
pub fn color_for_status(status: &Status) -> &'static str {
    match status {
        Status::Match => "\x1b[32m",        // green
        Status::Mismatch => "\x1b[33m",     // yellow
        Status::NotInstalled => "\x1b[31m", // red
    }
}

/// Format reports as pretty human-readable output
pub fn pretty_output(reports: &[ToolReport]) -> String {
    let mut s = String::new();
    s.push_str("Tools status\n");
    for r in reports {
        let color = color_for_status(&r.status);
        let reset = "\x1b[0m";
        let status_label = match r.status {
            Status::Match => "match",
            Status::Mismatch => "mismatch",
            Status::NotInstalled => "not_installed",
        };
        let installed = r.installed.as_deref().unwrap_or("-");
        s.push_str(&format!(
            "{}{}{}: expected={}, installed={} [{}]\n",
            color, r.name, reset, r.expected, installed, status_label
        ));
    }
    s
}

/// Run the get command
pub fn run_get(file: &str, output_format: OutputFormat, output: Option<&str>) {
    let config = Config::new(file);
    let reports = collect_reports(&config);

    let content = match output_format {
        OutputFormat::Json => {
            let wrapper = Reports {
                tools: reports.clone(),
            };
            serde_json::to_string_pretty(&wrapper)
                .unwrap_or_else(|e| format!("{{\"error\":\"{}\"}}", e))
        }
        OutputFormat::Yaml => {
            let wrapper = Reports {
                tools: reports.clone(),
            };
            serde_yaml::to_string(&wrapper).unwrap_or_else(|e| format!("error: {}", e))
        }
        OutputFormat::Toml => {
            let wrapper = Reports {
                tools: reports.clone(),
            };
            toml::to_string(&wrapper).unwrap_or_else(|e| format!("error = \"{}\"", e))
        }
        OutputFormat::Pretty => pretty_output(&reports),
    };

    if let Some(path) = output {
        if let Err(e) = fs::write(path, content) {
            eprintln!("Failed to write output: {}", e);
        }
    } else {
        println!("{}", content);
    }
}