prodigy 0.4.4

Turn ad-hoc Claude sessions into reproducible development pipelines with parallel AI agents
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use serde::{Deserialize, Serialize};
use std::time::Duration;

/// Progress visualization configuration for workflows
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProgressConfig {
    /// Display mode for progress visualization
    #[serde(default = "default_display_mode")]
    pub display_mode: ProgressDisplayMode,

    /// Update interval for progress bars (in milliseconds)
    #[serde(default = "default_update_interval")]
    pub update_interval: u64,

    /// Whether to show resource usage (CPU, memory, disk)
    #[serde(default = "default_show_resource_usage")]
    pub show_resource_usage: bool,

    /// Whether to enable web dashboard
    #[serde(default)]
    pub enable_dashboard: bool,

    /// Port for the web dashboard
    #[serde(default = "default_dashboard_port")]
    pub dashboard_port: u16,

    /// Log level for progress output
    #[serde(default = "default_log_level")]
    pub log_level: LogLevel,

    /// Window size for ETA calculation
    #[serde(default = "default_eta_window_size")]
    pub eta_window_size: usize,

    /// Whether to persist progress for resume
    #[serde(default = "default_persist_progress")]
    pub persist_progress: bool,

    /// Whether to show per-agent progress in MapReduce
    #[serde(default = "default_show_agent_progress")]
    pub show_agent_progress: bool,
}

impl Default for ProgressConfig {
    fn default() -> Self {
        Self {
            display_mode: default_display_mode(),
            update_interval: default_update_interval(),
            show_resource_usage: default_show_resource_usage(),
            enable_dashboard: false,
            dashboard_port: default_dashboard_port(),
            log_level: default_log_level(),
            eta_window_size: default_eta_window_size(),
            persist_progress: default_persist_progress(),
            show_agent_progress: default_show_agent_progress(),
        }
    }
}

/// Display mode for progress visualization
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum ProgressDisplayMode {
    /// Rich terminal UI with colors and animations
    Rich,
    /// Simple progress bars without animations
    Simple,
    /// JSON output for machine parsing
    Json,
    /// No progress display
    None,
}

/// Log level for progress output
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum LogLevel {
    Debug,
    Info,
    Warn,
    Error,
}

fn default_display_mode() -> ProgressDisplayMode {
    ProgressDisplayMode::Rich
}

fn default_update_interval() -> u64 {
    100 // milliseconds
}

fn default_show_resource_usage() -> bool {
    true
}

fn default_dashboard_port() -> u16 {
    8080
}

fn default_log_level() -> LogLevel {
    LogLevel::Info
}

fn default_eta_window_size() -> usize {
    20
}

fn default_persist_progress() -> bool {
    true
}

fn default_show_agent_progress() -> bool {
    true
}

impl ProgressConfig {
    /// Create configuration from environment variables
    pub fn from_env() -> Self {
        let mut config = Self::default();

        if let Ok(mode) = std::env::var("PRODIGY_PROGRESS_MODE") {
            config.display_mode = match mode.to_lowercase().as_str() {
                "rich" => ProgressDisplayMode::Rich,
                "simple" => ProgressDisplayMode::Simple,
                "json" => ProgressDisplayMode::Json,
                "none" => ProgressDisplayMode::None,
                _ => ProgressDisplayMode::Rich,
            };
        }

        if let Ok(dashboard) = std::env::var("PRODIGY_ENABLE_DASHBOARD") {
            config.enable_dashboard = dashboard.eq_ignore_ascii_case("true");
        }

        if let Ok(port) = std::env::var("PRODIGY_DASHBOARD_PORT") {
            if let Ok(p) = port.parse() {
                config.dashboard_port = p;
            }
        }

        if let Ok(resources) = std::env::var("PRODIGY_SHOW_RESOURCES") {
            config.show_resource_usage = resources.eq_ignore_ascii_case("true");
        }

        config
    }

    /// Get the update interval as a Duration
    pub fn update_interval_duration(&self) -> Duration {
        Duration::from_millis(self.update_interval)
    }
}