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

//! Events command implementation
//!
//! This module handles event viewing and management for MapReduce operations.

use crate::cli::args::EventCommands;
use anyhow::Result;

/// Validate duration string format (e.g., "7d", "24h", "365d")
fn is_valid_duration(duration: &str) -> bool {
    if duration.is_empty() {
        return false;
    }

    let suffix = duration.chars().last();
    let number_part = &duration[..duration.len() - 1];

    // Check suffix is valid and number part is a valid positive number
    matches!(suffix, Some('d') | Some('h') | Some('m') | Some('s'))
        && number_part.parse::<u64>().is_ok()
}

/// Execute events-related commands
pub async fn run_events_command(command: EventCommands) -> Result<()> {
    match command {
        EventCommands::Ls {
            job_id: _job_id,
            event_type: _event_type,
            agent_id: _agent_id,
            since: _since,
            limit: _limit,
            file: _file,
        } => {
            println!("Listing events...");
            Ok(())
        }
        EventCommands::Stats {
            file: _file,
            group_by: _group_by,
        } => {
            println!("Showing event statistics...");
            Ok(())
        }
        EventCommands::Search {
            pattern: _pattern,
            file: _file,
            fields: _fields,
        } => {
            println!("Searching events...");
            Ok(())
        }
        EventCommands::Follow {
            file: _file,
            job_id: _job_id,
            event_type: _event_type,
        } => {
            println!("Following events in real-time...");
            Ok(())
        }
        EventCommands::Clean {
            older_than,
            max_events: _max_events,
            max_size: _max_size,
            dry_run,
            archive,
            archive_path: _archive_path,
            all_jobs: _all_jobs,
            job_id: _job_id,
            file: _file,
        } => {
            // Validate duration format if provided
            if let Some(duration_str) = older_than {
                if !is_valid_duration(&duration_str) {
                    return Err(anyhow::anyhow!("Invalid duration format: {}", duration_str));
                }
            }

            if dry_run {
                println!("DRY RUN: Would clean old events (no changes will be made)");
                if archive {
                    println!("Would archive events before deletion");
                }
            } else {
                println!("Cleaning old events...");
                if archive {
                    println!("Archiving events before deletion...");
                }
            }
            Ok(())
        }
        EventCommands::Export {
            file: _file,
            format: _format,
            output: _output,
        } => {
            println!("Exporting events...");
            Ok(())
        }
    }
}