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
139
140
141
142
143
144
145
146
147

//! Mock worktree manager for testing

use crate::worktree::WorktreeSession;
use anyhow::Result;
use std::path::PathBuf;
use std::sync::{Arc, Mutex};

/// Builder for creating configured mock worktree managers
pub struct MockWorktreeManagerBuilder {
    session: Option<WorktreeSession>,
    fail_on_create: Option<String>,
    fail_on_cleanup: Option<String>,
}

impl Default for MockWorktreeManagerBuilder {
    fn default() -> Self {
        Self::new()
    }
}

impl MockWorktreeManagerBuilder {
    pub fn new() -> Self {
        Self {
            session: None,
            fail_on_create: None,
            fail_on_cleanup: None,
        }
    }

    pub fn with_session(mut self, session: WorktreeSession) -> Self {
        self.session = Some(session);
        self
    }

    pub fn fail_on_create(mut self, error: &str) -> Self {
        self.fail_on_create = Some(error.to_string());
        self
    }

    pub fn fail_on_cleanup(mut self, error: &str) -> Self {
        self.fail_on_cleanup = Some(error.to_string());
        self
    }

    pub fn build(self) -> MockWorktreeManager {
        MockWorktreeManager {
            session: Arc::new(Mutex::new(self.session)),
            fail_on_create: self.fail_on_create,
            fail_on_cleanup: self.fail_on_cleanup,
            create_count: Arc::new(Mutex::new(0)),
            cleanup_count: Arc::new(Mutex::new(0)),
        }
    }
}

/// Mock implementation of WorktreeManager for testing
pub struct MockWorktreeManager {
    session: Arc<Mutex<Option<WorktreeSession>>>,
    fail_on_create: Option<String>,
    fail_on_cleanup: Option<String>,
    create_count: Arc<Mutex<usize>>,
    cleanup_count: Arc<Mutex<usize>>,
}

impl Default for MockWorktreeManager {
    fn default() -> Self {
        Self::new()
    }
}

impl MockWorktreeManager {
    pub fn new() -> Self {
        Self {
            session: Arc::new(Mutex::new(None)),
            fail_on_create: None,
            fail_on_cleanup: None,
            create_count: Arc::new(Mutex::new(0)),
            cleanup_count: Arc::new(Mutex::new(0)),
        }
    }

    pub fn builder() -> MockWorktreeManagerBuilder {
        MockWorktreeManagerBuilder::new()
    }

    pub fn get_create_count(&self) -> usize {
        *self.create_count.lock().unwrap()
    }

    pub fn get_cleanup_count(&self) -> usize {
        *self.cleanup_count.lock().unwrap()
    }
}

impl MockWorktreeManager {
    pub async fn create_session(&self) -> Result<WorktreeSession> {
        *self.create_count.lock().unwrap() += 1;

        if let Some(error) = &self.fail_on_create {
            return Err(anyhow::anyhow!(error.clone()));
        }

        if let Some(session) = &*self.session.lock().unwrap() {
            Ok(session.clone())
        } else {
            // Return a default session
            Ok(WorktreeSession {
                name: "test-worktree".to_string(),
                path: PathBuf::from("/tmp/worktree"),
                branch: "test-branch".to_string(),
                created_at: chrono::Utc::now(),
            })
        }
    }

    pub async fn cleanup_session(&self, _name: &str) -> Result<()> {
        *self.cleanup_count.lock().unwrap() += 1;

        if let Some(error) = &self.fail_on_cleanup {
            return Err(anyhow::anyhow!(error.clone()));
        }

        Ok(())
    }

    pub async fn list_sessions(&self) -> Result<Vec<WorktreeSession>> {
        if let Some(session) = &*self.session.lock().unwrap() {
            Ok(vec![session.clone()])
        } else {
            Ok(vec![])
        }
    }

    pub async fn get_session(&self, _name: &str) -> Result<Option<WorktreeSession>> {
        Ok(self.session.lock().unwrap().clone())
    }

    pub async fn cleanup_all(&self) -> Result<()> {
        *self.cleanup_count.lock().unwrap() += 1;

        if let Some(error) = &self.fail_on_cleanup {
            return Err(anyhow::anyhow!(error.clone()));
        }

        Ok(())
    }
}