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

//! Exec command implementation
//!
//! This module handles the execution of single commands with retry support.

use anyhow::Result;
use std::path::PathBuf;

/// Execute a single command with retry support
pub async fn run_exec_command(
    command: String,
    retry: u32,
    timeout: Option<u64>,
    path: Option<PathBuf>,
) -> Result<()> {
    use crate::cli::workflow_generator::{generate_exec_workflow, TemporaryWorkflow};

    // Change to specified directory if provided
    if let Some(p) = path.clone() {
        std::env::set_current_dir(&p)?;
    }

    println!("🚀 Executing command: {}", command);
    if retry > 1 {
        println!("   Retry attempts: {}", retry);
    }
    if let Some(t) = timeout {
        println!("   Timeout: {}s", t);
    }

    // Generate temporary workflow
    let (_workflow, temp_path) = generate_exec_workflow(&command, retry, timeout)?;
    let _temp_workflow = TemporaryWorkflow {
        path: temp_path.clone(),
    };

    // Execute using cook command
    let cook_cmd = crate::cook::command::CookCommand {
        playbook: temp_path,
        path,
        max_iterations: 1,
        map: vec![],
        args: vec![],
        fail_fast: false,
        auto_accept: true,
        resume: None,
        quiet: false,
        verbosity: 0,
        dry_run: false,
        params: std::collections::HashMap::new(),
    };

    crate::cook::cook(cook_cmd).await
}

/// Execute a batch of commands on multiple files
pub async fn run_batch_command(
    pattern: String,
    command: String,
    parallel: usize,
    retry: Option<u32>,
    timeout: Option<u64>,
    path: Option<PathBuf>,
) -> Result<()> {
    use crate::cli::workflow_generator::{generate_batch_workflow, TemporaryWorkflow};

    // Change to specified directory if provided
    if let Some(p) = path.clone() {
        std::env::set_current_dir(&p)?;
    }

    println!("📦 Starting batch processing");
    println!("   Pattern: {}", pattern);
    println!("   Command: {}", command);
    println!("   Parallel workers: {}", parallel);
    if let Some(r) = retry {
        println!("   Retry attempts: {}", r);
    }
    if let Some(t) = timeout {
        println!("   Timeout per file: {}s", t);
    }

    // Generate temporary workflow
    let (_workflow, temp_path) =
        generate_batch_workflow(&pattern, &command, parallel, retry, timeout)?;
    let _temp_workflow = TemporaryWorkflow {
        path: temp_path.clone(),
    };

    // Execute using cook command
    let cook_cmd = crate::cook::command::CookCommand {
        playbook: temp_path,
        path,
        max_iterations: 1,
        map: vec![],
        args: vec![],
        fail_fast: false,
        auto_accept: true,
        resume: None,
        quiet: false,
        verbosity: 0,
        dry_run: false,
        params: std::collections::HashMap::new(),
    };

    crate::cook::cook(cook_cmd).await
}