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 hooks: Vec<Hook>,
    pub hook_results: HashMap<usize, HookResult>,
    pub started_at: DateTime<Utc>,
    pub finished_at: Option<DateTime<Utc>>,
    pub current_hook_started_at: Option<DateTime<Utc>>,
    pub completed_display_until: 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)

hooks: Vec<Hook>

The list of hooks being executed (for display purposes)

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)

current_hook_started_at: Option<DateTime<Utc>>

Timestamp when the current hook started (if running)

completed_display_until: Option<DateTime<Utc>>

Timestamp until which completed state should be displayed

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, hooks: Vec<Hook>, ) -> 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

pub fn current_hook_duration(&self) -> Option<Duration>

Get current hook duration (if a hook is currently running)

pub fn current_hook(&self) -> Option<&Hook>

Get the currently executing hook

pub fn format_duration(duration: Duration) -> String

Format duration in human-readable format (e.g., “2.3s”, “1m 15s”, “2h 5m”)

pub fn current_hook_display(&self) -> Option<String>

Get a short description of the current or next hook for display

pub fn should_display_completed(&self) -> bool

Check if the completed state should still be displayed

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