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

//! Environment types for MapReduce effect execution
//!
//! This module defines environment types used with Stillwater's Effect pattern
//! for dependency injection in MapReduce operations.

use crate::cook::execution::mapreduce::agent_command_executor::AgentCommandExecutor;
use crate::cook::execution::mapreduce::checkpoint::storage::CheckpointStorage;
use crate::cook::workflow::WorkflowStep;
use crate::worktree::WorktreeManager;
use serde_json::Value;
use std::collections::HashMap;
use std::sync::Arc;

/// Environment for map phase operations
///
/// Provides dependencies needed for executing agents including worktree
/// management, command execution, and checkpoint storage.
#[derive(Clone)]
pub struct MapEnv {
    /// Worktree manager for git operations
    pub worktree_manager: Arc<WorktreeManager>,
    /// Command executor for agent commands
    pub command_executor: Arc<AgentCommandExecutor>,
    /// Checkpoint storage for state persistence
    pub storage: Arc<dyn CheckpointStorage>,
    /// Agent template commands
    pub agent_template: Vec<WorkflowStep>,
    /// Job ID for tracking
    pub job_id: String,
    /// Maximum parallel agents
    pub max_parallel: usize,
    /// Workflow environment variables
    pub workflow_env: HashMap<String, Value>,
    /// Additional configuration
    pub config: HashMap<String, Value>,
}

/// Environment for phase operations (setup/reduce)
///
/// Provides dependencies for non-agent phases including command execution
/// and state management.
#[derive(Clone)]
pub struct PhaseEnv {
    /// Command executor for phase commands
    pub command_executor: Arc<AgentCommandExecutor>,
    /// Checkpoint storage for state persistence
    pub storage: Arc<dyn CheckpointStorage>,
    /// Variables from workflow and previous phases
    pub variables: HashMap<String, Value>,
    /// Workflow environment variables
    pub workflow_env: HashMap<String, Value>,
}

/// Parameters for constructing MapEnv
pub struct MapEnvParams {
    pub worktree_manager: Arc<WorktreeManager>,
    pub command_executor: Arc<AgentCommandExecutor>,
    pub storage: Arc<dyn CheckpointStorage>,
    pub agent_template: Vec<WorkflowStep>,
    pub job_id: String,
    pub max_parallel: usize,
    pub workflow_env: HashMap<String, Value>,
    pub config: HashMap<String, Value>,
}

impl MapEnv {
    /// Create a new map environment
    pub fn new(params: MapEnvParams) -> Self {
        let worktree_manager = params.worktree_manager;
        let command_executor = params.command_executor;
        let storage = params.storage;
        let agent_template = params.agent_template;
        let job_id = params.job_id;
        let max_parallel = params.max_parallel;
        let workflow_env = params.workflow_env;
        let config = params.config;

        Self {
            worktree_manager,
            command_executor,
            storage,
            agent_template,
            job_id,
            max_parallel,
            workflow_env,
            config,
        }
    }
}

impl PhaseEnv {
    /// Create a new phase environment
    pub fn new(
        command_executor: Arc<AgentCommandExecutor>,
        storage: Arc<dyn CheckpointStorage>,
        variables: HashMap<String, Value>,
        workflow_env: HashMap<String, Value>,
    ) -> Self {
        Self {
            command_executor,
            storage,
            variables,
            workflow_env,
        }
    }
}