Enum RebaseEvent 

pub enum RebaseEvent {
    Started {
        phase: RebasePhase,
        target_branch: String,
    },
    ConflictDetected {
        files: Vec<PathBuf>,
    },
    ConflictResolved {
        files: Vec<PathBuf>,
    },
    Succeeded {
        phase: RebasePhase,
        new_head: String,
    },
    Failed {
        phase: RebasePhase,
        reason: String,
    },
    Aborted {
        phase: RebasePhase,
        restored_to: String,
    },
    Skipped {
        phase: RebasePhase,
        reason: String,
    },
}

Rebase operation events.

Events related to git rebase operations including conflict detection and resolution. Rebase operations can occur at multiple points in the pipeline (initial and post-review).

State Machine

NotStarted -> InProgress -> Conflicted -> InProgress -> Completed
                   |                           |
                   +---------> Skipped <-------+
                   |
                   +---------> Failed (resets to NotStarted)

Emitted By

• Rebase handlers in handler/rebase.rs
• Git integration layer

Variants

Started

Rebase operation started.

Emitted when a rebase begins. The reducer uses this to:

• Track which rebase phase is active (initial or post-review)
• Record the target branch for observability

Fields

phase: RebasePhase

The rebase phase (initial or post-review).

target_branch: String

The target branch to rebase onto.

ConflictDetected

Merge conflict detected during rebase.

Emitted when git detects merge conflicts. The handler will attempt automated resolution; the reducer tracks which files are conflicted.

Fields

files: Vec<PathBuf>

The files with conflicts.

ConflictResolved

Merge conflicts were resolved.

Emitted after successful conflict resolution. The reducer uses this to clear the conflict state and allow rebase to continue.

Fields

files: Vec<PathBuf>

The files that were resolved.

Succeeded

Rebase completed successfully.

Emitted when rebase finishes without errors. The reducer uses this to:

• Mark rebase as complete
• Record the new HEAD commit
• Transition to the next pipeline phase

Fields

phase: RebasePhase

The rebase phase that completed.

new_head: String

The new HEAD after rebase.

Failed

Rebase failed and was reset.

Emitted when rebase encounters an unrecoverable error. The reducer uses this to decide whether to retry or abort the pipeline.

Fields

phase: RebasePhase

The rebase phase that failed.

reason: String

The reason for failure.

Aborted

Rebase was aborted and state restored.

Emitted when rebase is explicitly aborted (e.g., user interrupt). The reducer marks rebase as not attempted.

Fields

phase: RebasePhase

The rebase phase that was aborted.

restored_to: String

The commit that was restored.

Skipped

Rebase was skipped (e.g., already up to date).

Emitted when rebase is unnecessary. The reducer marks rebase as complete without actually performing the operation.

Fields

phase: RebasePhase

The rebase phase that was skipped.

reason: String

The reason for skipping.

Trait Implementations

impl Clone for RebaseEvent

fn clone(&self) -> RebaseEvent

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RebaseEvent

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RebaseEvent

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for RebaseEvent

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.