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

//! Git operation error types

use crate::error::{ErrorCode, ProdigyError};
use std::path::PathBuf;
use thiserror::Error;

/// Git-specific errors
#[derive(Debug, Error, Clone)]
pub enum GitError {
    #[error("Not a git repository")]
    NotARepository,

    #[error("Branch not found: {0}")]
    BranchNotFound(String),

    #[error("Branch already exists: {0}")]
    BranchExists(String),

    #[error("Merge conflict in files: {files:?}")]
    MergeConflict { files: Vec<PathBuf> },

    #[error("Uncommitted changes present")]
    UncommittedChanges,

    #[error("Nothing to commit, working tree clean")]
    NothingToCommit,

    #[error("Worktree already exists: {0}")]
    WorktreeExists(String),

    #[error("Worktree not found: {0}")]
    WorktreeNotFound(String),

    #[error("Commit not found: {0}")]
    CommitNotFound(String),

    #[error("Repository is in detached HEAD state")]
    DetachedHead,

    #[error("Git command failed: {0}")]
    CommandFailed(String),

    #[error("Invalid git reference: {0}")]
    InvalidReference(String),

    #[error("Working directory is dirty")]
    DirtyWorkingTree,

    #[error("Remote not found: {0}")]
    RemoteNotFound(String),

    #[error("Authentication failed")]
    AuthenticationFailed,

    #[error("Network error: {0}")]
    NetworkError(String),

    #[error("Repository locked")]
    RepositoryLocked,

    #[error("Invalid path: {0}")]
    InvalidPath(String),

    #[error("Permission denied")]
    PermissionDenied,
}

impl GitError {
    /// Check if this is a recoverable error
    pub fn is_recoverable(&self) -> bool {
        matches!(
            self,
            GitError::UncommittedChanges
                | GitError::NothingToCommit
                | GitError::DirtyWorkingTree
                | GitError::RepositoryLocked
        )
    }

    /// Check if this is a transient error that might succeed on retry
    pub fn is_transient(&self) -> bool {
        matches!(self, GitError::NetworkError(_) | GitError::RepositoryLocked)
    }
}

/// Convert GitError to ProdigyError
impl From<GitError> for ProdigyError {
    fn from(err: GitError) -> Self {
        let (code, operation) = match &err {
            GitError::NotARepository => (ErrorCode::GIT_NOT_REPO, "repository check"),
            GitError::BranchNotFound(_) => (ErrorCode::GIT_BRANCH_NOT_FOUND, "branch lookup"),
            GitError::BranchExists(_) => (ErrorCode::GIT_BRANCH_EXISTS, "branch creation"),
            GitError::MergeConflict { .. } => (ErrorCode::GIT_MERGE_CONFLICT, "merge"),
            GitError::UncommittedChanges => (ErrorCode::GIT_UNCOMMITTED, "status check"),
            GitError::NothingToCommit => (ErrorCode::GIT_NOTHING_TO_COMMIT, "commit"),
            GitError::WorktreeExists(_) => (ErrorCode::GIT_WORKTREE_EXISTS, "worktree creation"),
            GitError::WorktreeNotFound(_) => (ErrorCode::GIT_WORKTREE_NOT_FOUND, "worktree lookup"),
            GitError::CommitNotFound(_) => (ErrorCode::GIT_COMMIT_NOT_FOUND, "commit lookup"),
            GitError::DetachedHead => (ErrorCode::GIT_DETACHED_HEAD, "branch check"),
            GitError::CommandFailed(_) => (ErrorCode::GIT_COMMAND_FAILED, "command execution"),
            GitError::InvalidReference(_) => (ErrorCode::GIT_INVALID_REF, "reference parsing"),
            GitError::DirtyWorkingTree => (ErrorCode::GIT_DIRTY, "working tree check"),
            GitError::RemoteNotFound(_) => (ErrorCode::GIT_REMOTE_NOT_FOUND, "remote lookup"),
            GitError::AuthenticationFailed => (ErrorCode::GIT_AUTH_FAILED, "authentication"),
            GitError::NetworkError(_) => (ErrorCode::GIT_NETWORK, "network operation"),
            GitError::RepositoryLocked => (ErrorCode::GIT_REPO_LOCKED, "repository access"),
            GitError::InvalidPath(_) => (ErrorCode::GIT_INVALID_PATH, "path validation"),
            GitError::PermissionDenied => (ErrorCode::GIT_PERMISSION, "file access"),
        };

        ProdigyError::git(code, err.to_string(), operation).with_source(err)
    }
}