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 const fn set_prompt_size(&mut self, size: usize)

Set the prompt size.

pub const fn set_diff_info(&mut self, size: usize, was_truncated: bool)

Set the diff information.

pub fn set_raw_output(&mut self, output: &str)

Set the raw output from the agent.

Truncates very large outputs to prevent log file bloat.

pub fn add_extraction_attempt(&mut self, attempt: ExtractionAttempt)

Record an extraction attempt.

pub fn set_outcome(&mut self, outcome: AttemptOutcome)

Set the final outcome.

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.

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.