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

//! Unit tests for dry-run functionality

#[cfg(test)]
mod tests {
    use std::path::PathBuf;

    #[test]
    fn test_dry_run_flag_in_cook_command() {
        use crate::cook::command::CookCommand;
        use clap::Parser;

        // Test that dry-run flag is correctly parsed
        #[derive(Debug, Parser)]
        struct TestCli {
            #[command(flatten)]
            cook: CookCommand,
        }

        let args = TestCli::parse_from(["test", "workflow.yaml", "--dry-run"]);

        assert!(args.cook.dry_run);
        assert_eq!(args.cook.playbook, PathBuf::from("workflow.yaml"));
    }

    #[test]
    fn test_dry_run_with_iterations() {
        use crate::cook::command::CookCommand;
        use clap::Parser;

        #[derive(Debug, Parser)]
        struct TestCli {
            #[command(flatten)]
            cook: CookCommand,
        }

        let args = TestCli::parse_from(["test", "workflow.yaml", "--dry-run", "-n", "5"]);

        assert!(args.cook.dry_run);
        assert_eq!(args.cook.max_iterations, 5);
    }

    #[test]
    fn test_dry_run_always_uses_worktree() {
        use crate::cook::command::CookCommand;
        use clap::Parser;

        #[derive(Debug, Parser)]
        struct TestCli {
            #[command(flatten)]
            cook: CookCommand,
        }

        let args = TestCli::parse_from(["test", "workflow.yaml", "--dry-run"]);

        assert!(args.cook.dry_run);
        // In dry-run mode, worktree should not actually be created but would be in real mode
    }

    #[test]
    fn test_dry_run_with_auto_accept() {
        use crate::cook::command::CookCommand;
        use clap::Parser;

        #[derive(Debug, Parser)]
        struct TestCli {
            #[command(flatten)]
            cook: CookCommand,
        }

        let args = TestCli::parse_from(["test", "workflow.yaml", "--dry-run", "--yes"]);

        assert!(args.cook.dry_run);
        assert!(args.cook.auto_accept);
    }

    #[test]
    fn test_dry_run_with_verbosity() {
        use crate::cook::command::CookCommand;
        use clap::Parser;

        #[derive(Debug, Parser)]
        struct TestCli {
            #[command(flatten)]
            cook: CookCommand,
        }

        let args = TestCli::parse_from(["test", "workflow.yaml", "--dry-run", "-vv"]);

        assert!(args.cook.dry_run);
        assert_eq!(args.cook.verbosity, 2);
    }

    #[test]
    fn test_dry_run_workflow_config() {
        use crate::config::workflow::WorkflowConfig;

        let workflow = WorkflowConfig {
            name: None,
            commands: vec![],
            env: None,
            secrets: None,
            env_files: None,
            profiles: None,
            merge: None,
        };

        assert!(workflow.commands.is_empty());
        // In dry-run mode, this workflow should be analyzed but not executed
    }

    #[test]
    fn test_retention_analysis_serialization() {
        use crate::cook::execution::events::retention::RetentionAnalysis;
        use std::path::PathBuf;

        let analysis = RetentionAnalysis {
            file_path: PathBuf::from("/test/path"),
            events_total: 100,
            events_retained: 80,
            events_to_remove: 20,
            events_to_archive: 20,
            original_size_bytes: 10000,
            projected_size_bytes: 8000,
            space_to_save: 2000,
            estimated_duration_secs: 2.5,
            warnings: vec!["Test warning".to_string()],
        };

        // Test that the analysis can be serialized to JSON
        let json = serde_json::to_string(&analysis);
        assert!(json.is_ok());

        let json_str = json.unwrap();
        assert!(json_str.contains("\"events_total\":100"));
        assert!(json_str.contains("\"events_retained\":80"));
        assert!(json_str.contains("\"events_to_remove\":20"));
    }
}