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

use crate::error::{ErrorCode, ProdigyError};
use std::time::Duration;

#[derive(Debug, thiserror::Error)]
pub enum ProcessError {
    #[error("Command not found: {0}")]
    CommandNotFound(String),

    #[error("Process timed out after {0:?}")]
    Timeout(Duration),

    #[error("Process exited with code {0}")]
    ExitCode(i32),

    #[error("Process terminated by signal {0}")]
    Signal(i32),

    #[error("IO error: {0}")]
    Io(#[from] std::io::Error),

    #[error("UTF-8 conversion error: {0}")]
    Utf8(#[from] std::string::FromUtf8Error),

    #[error("Mock expectation not met: {0}")]
    MockExpectationNotMet(String),

    #[error("Failed to spawn process: {command}")]
    SpawnFailed {
        command: String,
        #[source]
        source: anyhow::Error,
    },

    #[error("Command failed: {command}")]
    CommandFailed {
        command: String,
        status: crate::subprocess::runner::ExitStatus,
        stderr: String,
    },

    #[error("IO error for command: {command}")]
    IoError {
        command: String,
        #[source]
        source: std::io::Error,
    },

    #[error("Internal error: {message}")]
    InternalError { message: String },
}

/// Convert ProcessError to ProdigyError
impl From<ProcessError> for ProdigyError {
    fn from(err: ProcessError) -> Self {
        let (code, command, exit_code) = match &err {
            ProcessError::CommandNotFound(cmd) => {
                (ErrorCode::EXEC_COMMAND_NOT_FOUND, Some(cmd.clone()), None)
            }
            ProcessError::Timeout(_) => (ErrorCode::EXEC_TIMEOUT, None, None),
            ProcessError::ExitCode(code) => (ErrorCode::EXEC_SUBPROCESS_FAILED, None, Some(*code)),
            ProcessError::Signal(sig) => (ErrorCode::EXEC_SIGNAL_RECEIVED, None, Some(*sig)),
            ProcessError::Io(_) => (ErrorCode::EXEC_SPAWN_FAILED, None, None),
            ProcessError::Utf8(_) => (ErrorCode::EXEC_OUTPUT_ERROR, None, None),
            ProcessError::MockExpectationNotMet(_) => (ErrorCode::EXEC_GENERIC, None, None),
            ProcessError::SpawnFailed { command, .. } => {
                (ErrorCode::EXEC_SPAWN_FAILED, Some(command.clone()), None)
            }
            ProcessError::CommandFailed {
                command, status, ..
            } => {
                let exit_code = status.code();
                (
                    ErrorCode::EXEC_SUBPROCESS_FAILED,
                    Some(command.clone()),
                    exit_code,
                )
            }
            ProcessError::IoError { command, .. } => {
                (ErrorCode::EXEC_SPAWN_FAILED, Some(command.clone()), None)
            }
            ProcessError::InternalError { .. } => (ErrorCode::EXEC_GENERIC, None, None),
        };

        let mut error = ProdigyError::execution_with_code(code, err.to_string(), command);
        if let ProdigyError::Execution {
            exit_code: ex_code, ..
        } = &mut error
        {
            *ex_code = exit_code;
        }
        error.with_source(err)
    }
}