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

use super::config::InputConfig;
use crate::cook::command::CookCommand;
use anyhow::Result;

/// Maintains compatibility with existing command line arguments
pub struct LegacyInputAdapter;

impl LegacyInputAdapter {
    /// Convert existing cook command to new input configuration
    pub fn from_cook_command(command: &CookCommand) -> Result<InputConfig> {
        let mut config = InputConfig::default();

        // Handle --args flag
        if !command.args.is_empty() {
            // Join all args with commas for backward compatibility
            let args_str = command.args.join(",");
            config = InputConfig::from_command_args(&args_str);
        }

        // Handle --map flag
        if !command.map.is_empty() {
            // If we have both --args and --map, create a composite source
            if !command.args.is_empty() {
                let args_source = super::config::InputSource::Arguments {
                    value: command.args.join(","),
                    separator: Some(",".to_string()),
                    validation: None,
                };

                let file_source = super::config::InputSource::FilePattern {
                    patterns: command.map.clone(),
                    recursive: false,
                    filters: None,
                };

                config.sources = vec![super::config::InputSource::Composite {
                    sources: vec![args_source, file_source],
                    merge_strategy: super::config::MergeStrategy::Sequential,
                }];
            } else {
                config = InputConfig::from_file_patterns(command.map.clone());
            }
        }

        // If no inputs specified, use empty source
        if command.args.is_empty() && command.map.is_empty() {
            config.sources = vec![super::config::InputSource::Empty];
        }

        Ok(config)
    }

    /// Check if the configuration supports MapReduce
    pub fn supports_mapreduce(config: &InputConfig) -> bool {
        config.sources.iter().any(|source| {
            matches!(
                source,
                super::config::InputSource::FilePattern { .. }
                    | super::config::InputSource::StructuredData { .. }
                    | super::config::InputSource::Composite { .. }
            )
        })
    }

    /// Convert execution inputs to legacy format for existing code
    pub fn to_legacy_format(inputs: &[super::ExecutionInput]) -> Vec<String> {
        inputs
            .iter()
            .map(|input| {
                // Try to get the most appropriate value for legacy compatibility
                if let Some(file_path) = input.variables.get("file_path") {
                    file_path.to_string()
                } else if let Some(arg) = input.variables.get("arg") {
                    arg.to_string()
                } else if let Some(item) = input.variables.get("item") {
                    item.to_string()
                } else {
                    input.id.clone()
                }
            })
            .collect()
    }
}