help-probe 0.1.0

CLI tool discovery and automation framework that extracts structured information from command help text
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

use help_probe::builder::{Language, generate_command_builder};
use help_probe::model::{ArgumentSpec, ArgumentType, OptionSpec, ProbeResult};

fn create_test_result() -> ProbeResult {
    ProbeResult {
        command: "mytool".to_string(),
        args: vec!["--help".to_string()],
        exit_code: Some(0),
        timed_out: false,
        help_flag_detected: true,
        usage_blocks: vec![],
        options: vec![
            OptionSpec {
                short_flags: vec!["-v".to_string()],
                long_flags: vec!["--verbose".to_string()],
                description: Some("Verbose output".to_string()),
                option_type: help_probe::model::OptionType::Boolean,
                required: false,
                default_value: None,
                takes_argument: false,
                argument_name: None,
                choices: vec![],
            },
            OptionSpec {
                short_flags: vec![],
                long_flags: vec!["--file".to_string()],
                description: Some("Input file".to_string()),
                option_type: help_probe::model::OptionType::Path,
                required: false,
                default_value: None,
                takes_argument: true,
                argument_name: Some("FILE".to_string()),
                choices: vec![],
            },
        ],
        subcommands: vec![],
        arguments: vec![ArgumentSpec {
            name: "FILE".to_string(),
            description: Some("Input file".to_string()),
            required: true,
            variadic: false,
            arg_type: Some(ArgumentType::Path),
            placeholder: Some("<FILE>".to_string()),
        }],
        examples: vec![],
        environment_variables: vec![],
        validation_rules: vec![],
        raw_stdout: String::new(),
        raw_stderr: String::new(),
    }
}

#[test]
fn generate_rust_builder() {
    let result = create_test_result();
    let rust_code = generate_command_builder(&result, Language::Rust);

    // Check that it contains expected elements
    assert!(rust_code.contains("MytoolBuilder"));
    assert!(rust_code.contains("pub fn verbose"));
    assert!(rust_code.contains("pub fn file"));
    assert!(rust_code.contains("pub fn file("));
    assert!(rust_code.contains("pub fn build"));
    assert!(rust_code.contains("pub fn execute"));
}

#[test]
fn generate_python_builder() {
    let result = create_test_result();
    let python_code = generate_command_builder(&result, Language::Python);

    assert!(python_code.contains("class MytoolBuilder"));
    assert!(python_code.contains("def verbose"));
    assert!(python_code.contains("def file"));
}

#[test]
fn generate_javascript_builder() {
    let result = create_test_result();
    let js_code = generate_command_builder(&result, Language::JavaScript);

    assert!(js_code.contains("class MytoolBuilder"));
    assert!(js_code.contains("verbose()"));
    assert!(js_code.contains("file(value)"));
}

#[test]
fn generate_typescript_builder() {
    let result = create_test_result();
    let ts_code = generate_command_builder(&result, Language::TypeScript);

    assert!(ts_code.contains("export class MytoolBuilder"));
    assert!(ts_code.contains("verbose(): MytoolBuilder"));
    assert!(ts_code.contains("file(value: string)"));
}

#[test]
fn language_from_str() {
    use help_probe::builder::Language;

    assert_eq!(Language::from_str("rust"), Some(Language::Rust));
    assert_eq!(Language::from_str("RUST"), Some(Language::Rust));
    assert_eq!(Language::from_str("python"), Some(Language::Python));
    assert_eq!(Language::from_str("py"), Some(Language::Python));
    assert_eq!(Language::from_str("javascript"), Some(Language::JavaScript));
    assert_eq!(Language::from_str("js"), Some(Language::JavaScript));
    assert_eq!(Language::from_str("typescript"), Some(Language::TypeScript));
    assert_eq!(Language::from_str("ts"), Some(Language::TypeScript));
    assert_eq!(Language::from_str("invalid"), None);
}