r2x 0.1.0

A framework plugin manager for the r2x power systems modeling ecosystem.
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

use crate::manifest_lookup::resolve_plugin_ref;
use colored::Colorize;
use r2x_logger as logger;
use r2x_manifest::types::Manifest;

/// Show help for the run command when invoked with no arguments
pub fn show_run_help() -> Result<(), String> {
    let manifest = Manifest::load().map_err(|e| format!("Failed to load manifest: {}", e))?;

    println!();
    println!("{}", "No pipeline or plugin specified.".bold());
    println!();

    // Show installed plugins
    if manifest.is_empty() {
        println!("{}", "No plugins installed.".yellow());
        println!("Install plugins with: r2x install <package>");
        println!();
    } else {
        println!("{}", "Installed plugins:".bold());
        for pkg in &manifest.packages {
            for plugin in &pkg.plugins {
                let plugin_type = format!("{:?}", plugin.plugin_type);
                println!(
                    "  {} {} - from package {}",
                    plugin.name.as_ref().cyan(),
                    format!("({})", plugin_type).dimmed(),
                    pkg.name.as_ref().dimmed()
                );
            }
        }
        println!();
    }

    // Show usage hints
    println!("{}", "Usage:".bold());
    println!("  Run a pipeline:");
    println!("    r2x run <pipeline.yaml> [pipeline-name]");
    println!();
    println!("  Run a plugin directly:");
    println!("    r2x run plugin <plugin-name> [OPTIONS]");
    println!("      (use -q for quiet logs, -q -q to suppress plugin stdout)");
    println!();
    println!("  Get plugin help:");
    println!("    r2x run plugin <plugin-name> --show-help");
    println!();
    println!("  List pipelines in YAML:");
    println!("    r2x run <pipeline.yaml> --list");
    println!();
    println!("  Print resolved pipeline config:");
    println!("    r2x run <pipeline.yaml> --print <pipeline-name>");
    println!();

    Ok(())
}

/// Show detailed help for a specific plugin
pub fn show_plugin_help(plugin_name: &str) -> Result<(), String> {
    let manifest = Manifest::load().map_err(|e| format!("Failed to load manifest: {}", e))?;

    let resolved = resolve_plugin_ref(&manifest, plugin_name).map_err(|e| e.to_string())?;
    let plugin = resolved.plugin;

    logger::step(&format!("Plugin: {}", plugin_name));

    println!("\nType: {:?}", plugin.plugin_type);
    println!("Module: {}", plugin.module);

    // Show class or function name
    if let Some(ref class_name) = plugin.class_name {
        println!("Class: {}", class_name);
    }
    if let Some(ref function_name) = plugin.function_name {
        println!("Function: {}", function_name);
    }

    // Show config if available
    if let Some(ref config_class) = plugin.config_class {
        print!("\nConfiguration Class: {}", config_class);
        if let Some(ref config_module) = plugin.config_module {
            print!(" ({})", config_module);
        }
        println!();
    }

    // Show parameters
    if !plugin.parameters.is_empty() {
        println!("\nParameters:");
        for param in &plugin.parameters {
            let module_str = param
                .module
                .as_ref()
                .map(|m| format!(" ({})", m))
                .unwrap_or_default();
            println!(
                "  --{:<20} {}{}",
                param.name,
                param.format_types(),
                module_str
            );
            if let Some(ref desc) = param.description {
                println!("      {}", desc);
            }
        }
    }

    // Show config schema
    if !plugin.config_schema.is_empty() {
        println!("\nConfiguration Schema:");
        for (field_name, field) in plugin.config_schema.iter() {
            let req_marker = if field.required { " (required)" } else { "" };
            println!(
                "  --{:<20} {:?}{}",
                field_name, field.field_type, req_marker
            );
        }
    }

    println!("\nUsage:");
    println!("  r2x run plugin {} [OPTIONS]", plugin_name);
    println!("    (add -q to silence logs, -q -q to hide stdout)");
    println!("\nExamples:");
    println!("  r2x run --plugin {} --show-help", plugin_name);
    println!("  r2x run --plugin {} <args>", plugin_name);

    Ok(())
}