mecha10-cli 0.1.47

Mecha10 CLI tool
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

//! Template definitions and selection logic
//!
//! Provides template metadata and helper functions for template selection.

use super::types::TemplateType;

/// A project template with metadata
#[derive(Debug, Clone)]
pub struct Template {
    /// Template type
    pub template_type: TemplateType,
    /// Node IDs to include by default
    pub default_nodes: Vec<String>,
}

impl Template {
    /// Create a new template
    pub fn new(template_type: TemplateType, default_nodes: Vec<String>) -> Self {
        Self {
            template_type,
            default_nodes,
        }
    }

    /// Get template ID
    pub fn id(&self) -> &'static str {
        self.template_type.as_str()
    }

    /// Get template name
    pub fn name(&self) -> &'static str {
        self.template_type.display_name()
    }

    /// Get template description
    pub fn description(&self) -> &'static str {
        self.template_type.description()
    }
}

/// Get all available templates
pub fn get_all_templates() -> Vec<Template> {
    vec![
        Template::new(
            TemplateType::Basic,
            vec![
                "speaker".to_string(),
                "listener".to_string(),
                "motor".to_string(),
                "imu".to_string(),
                "teleop".to_string(),
                "simulation-bridge".to_string(),
                "diagnostics-node".to_string(),
                "websocket-bridge".to_string(),
                "image-classifier".to_string(),
                "object-detector".to_string(),
                "llm-command".to_string(),
                "behavior-executor".to_string(),
            ],
        ),
        Template::new(
            TemplateType::Rover,
            vec![
                "speaker".to_string(),
                "listener".to_string(),
                "motor".to_string(),
                "imu".to_string(),
                "teleop".to_string(),
                "simulation-bridge".to_string(),
                "diagnostics-node".to_string(),
                "websocket-bridge".to_string(),
                "image-classifier".to_string(),
                "object-detector".to_string(),
                "llm-command".to_string(),
                "behavior-executor".to_string(),
            ],
        ),
        Template::new(
            TemplateType::Arm,
            vec![
                "speaker".to_string(),
                "listener".to_string(),
                "motor".to_string(),
                "imu".to_string(),
                "teleop".to_string(),
                "simulation-bridge".to_string(),
                "diagnostics-node".to_string(),
                "websocket-bridge".to_string(),
                "image-classifier".to_string(),
                "object-detector".to_string(),
                "llm-command".to_string(),
                "behavior-executor".to_string(),
            ],
        ),
        Template::new(
            TemplateType::Humanoid,
            vec![
                "speaker".to_string(),
                "listener".to_string(),
                "motor".to_string(),
                "imu".to_string(),
                "teleop".to_string(),
                "simulation-bridge".to_string(),
                "diagnostics-node".to_string(),
                "websocket-bridge".to_string(),
                "image-classifier".to_string(),
                "object-detector".to_string(),
                "llm-command".to_string(),
                "behavior-executor".to_string(),
            ],
        ),
    ]
}

/// Get a template by its ID
pub fn get_template_by_id(id: &str) -> Option<Template> {
    let template_type = TemplateType::from_str(id)?;
    get_all_templates()
        .into_iter()
        .find(|t| t.template_type == template_type)
}

/// Get a template by type
#[allow(dead_code)] // Tested, planned for future use
pub fn get_template_by_type(template_type: TemplateType) -> Template {
    get_all_templates()
        .into_iter()
        .find(|t| t.template_type == template_type)
        .expect("Template should exist for all TemplateType variants")
}