Struct CommitAttemptLog 

pub struct CommitAttemptLog {
    pub attempt_number: usize,
    pub agent: String,
    pub strategy: String,
    pub timestamp: DateTime<Local>,
    pub prompt_size_bytes: usize,
    pub diff_size_bytes: usize,
    pub diff_was_truncated: bool,
    pub raw_output: Option<String>,
    pub extraction_attempts: Vec<ExtractionAttempt>,
    pub validation_checks: Vec<ValidationCheck>,
    pub outcome: Option<AttemptOutcome>,
}

Per-attempt log for commit message generation.

Captures all details about a single attempt to generate a commit message, providing a complete audit trail for debugging.

Fields

attempt_number: usize

Attempt number within this session

agent: String

Agent being used (e.g., “claude”, “glm”)

strategy: String

Retry strategy (e.g., “initial”, “strict_json”)

timestamp: DateTime<Local>

Timestamp when attempt started

prompt_size_bytes: usize

Size of the prompt in bytes

diff_size_bytes: usize

Size of the diff in bytes

diff_was_truncated: bool

Whether the diff was pre-truncated

raw_output: Option<String>

Raw output from the agent (truncated if very large)

extraction_attempts: Vec<ExtractionAttempt>

Extraction attempts with their results

validation_checks: Vec<ValidationCheck>

Validation checks that were run

outcome: Option<AttemptOutcome>

Final outcome of this attempt

Implementations

impl CommitAttemptLog

pub fn new(attempt_number: usize, agent: &str, strategy: &str) -> Self

Create a new attempt log.

pub fn with_basics( attempt_number: usize, agent: &str, strategy: &str, prompt_size: usize, diff_size: usize, diff_was_truncated: bool, ) -> Self

Create a new attempt log with basic info already set.

This is the functional equivalent of calling new() followed by set_prompt_size() and set_diff_info(), avoiding let mut.

pub fn with_prompt_size(self, size: usize) -> Self

Set the prompt size (consuming builder).

pub fn with_diff_info(self, size: usize, was_truncated: bool) -> Self

Set the diff information (consuming builder).

pub fn with_raw_output(self, output: &str) -> Self

Set the raw output from the agent (consuming builder).

Truncates very large outputs to prevent log file bloat.

pub fn add_extraction_attempt(self, attempt: ExtractionAttempt) -> Self

Record an extraction attempt (consuming builder).

pub fn with_outcome(self, outcome: AttemptOutcome) -> Self

Set the final outcome (consuming builder).

pub fn write_to_workspace( &self, log_dir: &Path, workspace: &dyn Workspace, ) -> Result<PathBuf>

Write this log to a file using workspace abstraction.

This is the architecture-conformant version that uses the workspace trait instead of direct filesystem access.

Arguments

• log_dir - Directory to write the log file to (relative to workspace)
• workspace - The workspace to use for filesystem operations

Returns

Path to the written log file on success.

Errors

Returns error if the operation fails.

Trait Implementations

impl Clone for CommitAttemptLog

fn clone(&self) -> CommitAttemptLog

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CommitAttemptLog

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

Formats the value using the given formatter.