ricecoder 0.1.72

Terminal-first, spec-driven coding assistant that understands your project before generating code
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
133
134
135

//! Hooks command handler

use crate::error::{CliError, CliResult};
use ricecoder_hooks::{HookCli, HookCommand, InMemoryHookRegistry};

/// Hooks command action
#[derive(Debug, Clone)]
pub enum HooksAction {
    /// List all hooks
    List {
        /// Output format (table or json)
        format: Option<String>,
    },

    /// Inspect a specific hook
    Inspect {
        /// Hook ID
        id: String,

        /// Output format (table or json)
        format: Option<String>,
    },

    /// Enable a hook
    Enable {
        /// Hook ID
        id: String,
    },

    /// Disable a hook
    Disable {
        /// Hook ID
        id: String,
    },

    /// Delete a hook
    Delete {
        /// Hook ID
        id: String,
    },
}

/// Hooks command handler
pub struct HooksCommand {
    action: HooksAction,
}

impl HooksCommand {
    /// Create a new hooks command
    pub fn new(action: HooksAction) -> Self {
        Self { action }
    }

    /// Execute the hooks command
    pub fn execute(&self) -> CliResult<()> {
        // Create an in-memory registry for now
        // In the future, this should load from configuration
        let registry = InMemoryHookRegistry::new();
        let mut cli = HookCli::new(registry);

        let command = match &self.action {
            HooksAction::List { format } => HookCommand::List {
                format: format.clone(),
            },
            HooksAction::Inspect { id, format } => HookCommand::Inspect {
                id: id.clone(),
                format: format.clone(),
            },
            HooksAction::Enable { id } => HookCommand::Enable { id: id.clone() },
            HooksAction::Disable { id } => HookCommand::Disable { id: id.clone() },
            HooksAction::Delete { id } => HookCommand::Delete { id: id.clone() },
        };

        let result = cli
            .execute(command)
            .map_err(|e| CliError::Internal(format!("Hook command failed: {}", e)))?;

        println!("{}", result);
        Ok(())
    }
}

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

    #[test]
    fn test_hooks_list_action() {
        let action = HooksAction::List { format: None };
        let _cmd = HooksCommand::new(action);
        // Just verify it can be created
        assert!(true);
    }

    #[test]
    fn test_hooks_inspect_action() {
        let action = HooksAction::Inspect {
            id: "hook1".to_string(),
            format: None,
        };
        let _cmd = HooksCommand::new(action);
        // Just verify it can be created
        assert!(true);
    }

    #[test]
    fn test_hooks_enable_action() {
        let action = HooksAction::Enable {
            id: "hook1".to_string(),
        };
        let _cmd = HooksCommand::new(action);
        // Just verify it can be created
        assert!(true);
    }

    #[test]
    fn test_hooks_disable_action() {
        let action = HooksAction::Disable {
            id: "hook1".to_string(),
        };
        let _cmd = HooksCommand::new(action);
        // Just verify it can be created
        assert!(true);
    }

    #[test]
    fn test_hooks_delete_action() {
        let action = HooksAction::Delete {
            id: "hook1".to_string(),
        };
        let _cmd = HooksCommand::new(action);
        // Just verify it can be created
        assert!(true);
    }
}