guardy 0.2.4

Fast, secure git hooks in Rust with secret scanning and protected file synchronization
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

use anyhow::Result;
use clap::Args;

#[derive(Args, Clone, Default)]
pub struct StatusArgs {
    /// Increase verbosity (can be repeated)
    #[arg(short, long, action = clap::ArgAction::Count)]
    pub verbose: u8,

    /// Include configuration in status output
    #[arg(long)]
    pub show_config: Option<bool>,

    /// Output format (text, json, yaml)
    #[arg(long, value_enum)]
    pub format: Option<String>,

    /// Compact output (less detailed)
    #[arg(long)]
    pub compact: Option<bool>,
}

pub async fn execute(_args: StatusArgs) -> Result<()> {
    use crate::{
        cli::banner, cli::output::*, config::CONFIG, git::GitRepo,
        scan::static_data::patterns::get_pattern_library,
    };

    // Print banner without context
    banner::print_banner(None);

    // Check if we're in a git repository
    let repo = match GitRepo::discover() {
        Ok(repo) => {
            styled!("{} Git repository detected", ("✅", "success_symbol"));

            let branch = repo.current_branch()?;
            styled!("  Current branch: {}", (branch, "branch"));
            repo
        }
        Err(_) => {
            styled!("{} Not in a git repository", ("❌", "error_symbol"));
            return Ok(());
        }
    };

    // Show configuration details (CONFIG is always valid)
    styled!("{} Configuration loaded", ("✅", "success_symbol"));

    // Show key configuration details using direct field access
    styled!(
        "  Max file size: {}MB",
        (CONFIG.scanner.max_file_size_mb.to_string(), "number")
    );
    styled!(
        "  Include binary files: {}",
        (CONFIG.scanner.include_binary.to_string(), "property")
    );
    styled!(
        "  Entropy analysis: {}",
        (
            CONFIG.scanner.enable_entropy_analysis.to_string(),
            "property"
        )
    );

    // Check patterns
    let pattern_lib = get_pattern_library();
    styled!(
        "{} Scanner ready with {} patterns",
        ("✅", "success_symbol"),
        (pattern_lib.count().to_string(), "number")
    );

    // Check hook installation
    let hooks_dir = repo.git_dir().join("hooks");
    let hook_names = ["pre-commit", "commit-msg", "post-checkout", "pre-push"];
    let mut installed_hooks = Vec::new();
    let mut missing_hooks = Vec::new();

    for hook_name in &hook_names {
        let hook_path = hooks_dir.join(hook_name);
        if hook_path.exists() {
            // Check if it's a guardy hook
            if let Ok(content) = std::fs::read_to_string(&hook_path) {
                if content.contains("guardy hooks run") || content.contains("# Guardy hook") {
                    installed_hooks.push(*hook_name);
                } else {
                    styled!(
                        "  {} {} exists but not managed by guardy",
                        ("⚠️", "warning_symbol"),
                        (hook_name, "property")
                    );
                }
            }
        } else {
            missing_hooks.push(*hook_name);
        }
    }

    if !installed_hooks.is_empty() {
        styled!(
            "{} Installed hooks: {}",
            ("✅", "success_symbol"),
            (installed_hooks.join(", "), "property")
        );
    }

    if !missing_hooks.is_empty() {
        styled!(
            "{} Missing hooks: {}",
            ("❌", "error_symbol"),
            (missing_hooks.join(", "), "property")
        );
        styled!(
            "Run {} to install missing hooks",
            ("'guardy install'", "command")
        );
    }

    if installed_hooks.len() == hook_names.len() {
        styled!(
            "{} Guardy is fully configured and ready!",
            ("🎉", "success_symbol")
        );
    } else {
        styled!("Status: {}", ("Partially configured", "warning"));
    }

    Ok(())
}