Struct HookExecutionState 

pub struct HookExecutionState {

    pub instance_hash: String,
    pub directory_path: PathBuf,
    pub config_hash: String,
    pub status: ExecutionStatus,
    pub total_hooks: usize,
    pub completed_hooks: usize,
    pub current_hook_index: Option<usize>,
    pub hook_results: HashMap<usize, HookResult>,
    pub started_at: DateTime<Utc>,
    pub finished_at: Option<DateTime<Utc>>,
    pub error_message: Option<String>,
    pub environment_vars: HashMap<String, String>,
    pub previous_env: Option<HashMap<String, String>>,
}

Represents the state of hook execution for a specific directory

Fields

instance_hash: String

Hash combining directory path and config (instance identifier)

directory_path: PathBuf

Path to the directory being processed

config_hash: String

Hash of the configuration that was approved

status: ExecutionStatus

Current status of execution

total_hooks: usize

Total number of hooks to execute

completed_hooks: usize

Number of hooks completed so far

current_hook_index: Option<usize>

Index of currently executing hook (if any)

hook_results: HashMap<usize, HookResult>

Results of completed hooks

started_at: DateTime<Utc>

Timestamp when execution started

finished_at: Option<DateTime<Utc>>

Timestamp when execution finished (if completed)

error_message: Option<String>

Error message if execution failed

environment_vars: HashMap<String, String>

Environment variables captured from source hooks

previous_env: Option<HashMap<String, String>>

Previous environment variables (for diff/unset support)

Implementations

impl HookExecutionState

pub fn new( directory_path: PathBuf, instance_hash: String, config_hash: String, total_hooks: usize, ) -> Self

Create a new execution state

pub fn mark_hook_running(&mut self, hook_index: usize)

Mark a hook as currently executing

pub fn record_hook_result(&mut self, hook_index: usize, result: HookResult)

Record the result of a hook execution

pub fn mark_cancelled(&mut self, reason: Option<String>)

Mark execution as cancelled

pub fn is_complete(&self) -> bool

Check if execution is complete (success, failure, or cancelled)

pub fn progress_display(&self) -> String

Get a human-readable progress display

pub fn duration(&self) -> Duration

Get execution duration

Trait Implementations

impl Clone for HookExecutionState

fn clone(&self) -> HookExecutionState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HookExecutionState

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for HookExecutionState

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for HookExecutionState

fn eq(&self, other: &HookExecutionState) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for HookExecutionState

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for HookExecutionState

impl StructuralPartialEq for HookExecutionState