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

use super::provider::{InputConfig, InputProvider, ValidationIssue};
use super::types::{ExecutionInput, InputType, VariableDefinition, VariableType, VariableValue};
use anyhow::Result;
use async_trait::async_trait;

pub struct ArgumentsInputProvider;

#[async_trait]
impl InputProvider for ArgumentsInputProvider {
    fn input_type(&self) -> InputType {
        InputType::Arguments {
            separator: Some(",".to_string()),
        }
    }

    async fn validate(&self, config: &InputConfig) -> Result<Vec<ValidationIssue>> {
        let issues = Vec::new();

        // Check if args are provided
        if config.get_string("args").is_err() {
            // Not an error - just means no arguments provided
        }

        Ok(issues)
    }

    async fn generate_inputs(&self, config: &InputConfig) -> Result<Vec<ExecutionInput>> {
        let args_str = config.get_string("args")?;
        let separator = config
            .get_string("separator")
            .unwrap_or_else(|_| ",".to_string());

        let arguments: Vec<String> = args_str
            .split(&separator)
            .map(|s| s.trim().to_string())
            .filter(|s| !s.is_empty())
            .collect();

        let mut inputs = Vec::new();

        for (index, arg) in arguments.iter().enumerate() {
            let mut input = ExecutionInput::new(
                format!("arg_{}", index),
                InputType::Arguments {
                    separator: Some(separator.clone()),
                },
            );

            // Standard argument variables
            input.add_variable("arg".to_string(), VariableValue::String(arg.clone()));
            input.add_variable("arg_index".to_string(), VariableValue::Number(index as i64));
            input.add_variable(
                "arg_count".to_string(),
                VariableValue::Number(arguments.len() as i64),
            );

            // Try to parse as key=value pair
            if let Some((key, value)) = arg.split_once('=') {
                input.add_variable(
                    "arg_key".to_string(),
                    VariableValue::String(key.to_string()),
                );
                input.add_variable(
                    "arg_value".to_string(),
                    VariableValue::String(value.to_string()),
                );
            }

            inputs.push(input);
        }

        Ok(inputs)
    }

    fn available_variables(&self, _config: &InputConfig) -> Result<Vec<VariableDefinition>> {
        Ok(vec![
            VariableDefinition {
                name: "arg".to_string(),
                var_type: VariableType::String,
                description: "The current argument value".to_string(),
                required: true,
                default_value: None,
                validation_rules: vec![],
            },
            VariableDefinition {
                name: "arg_index".to_string(),
                var_type: VariableType::Number,
                description: "Zero-based index of the current argument".to_string(),
                required: true,
                default_value: None,
                validation_rules: vec![],
            },
            VariableDefinition {
                name: "arg_count".to_string(),
                var_type: VariableType::Number,
                description: "Total number of arguments".to_string(),
                required: true,
                default_value: None,
                validation_rules: vec![],
            },
            VariableDefinition {
                name: "arg_key".to_string(),
                var_type: VariableType::String,
                description: "Key part of key=value argument (if applicable)".to_string(),
                required: false,
                default_value: None,
                validation_rules: vec![],
            },
            VariableDefinition {
                name: "arg_value".to_string(),
                var_type: VariableType::String,
                description: "Value part of key=value argument (if applicable)".to_string(),
                required: false,
                default_value: None,
                validation_rules: vec![],
            },
        ])
    }

    fn supports(&self, config: &InputConfig) -> bool {
        config.get_string("args").is_ok()
    }
}