Struct AutoSaveLogger 

pub struct AutoSaveLogger { /* private fields */ }

Transaction logger with automatic persistence.

Wraps a TxLogger and automatically saves to ~/.ryo/ based on the configured TxLogMode.

Example

use ryo_core::storage::{AutoSaveLogger, TxLogMode};

// Create with auto-save on commit
let logger = AutoSaveLogger::new("/my/project", 100, TxLogMode::OnCommit)?;

// Log as usual
logger.log_mutation("Rename", "foo -> bar", 5);

// Trigger save (e.g., called from CodingWorld::commit_changes)
logger.on_commit()?;

// Finish and get the log
let log = logger.finish()?;

Implementations

impl AutoSaveLogger

pub fn new( project_path: impl Into<PathBuf>, file_count: usize, mode: TxLogMode, ) -> StorageResult<Self>

Create a new auto-save logger.

pub fn with_format( project_path: impl Into<PathBuf>, file_count: usize, mode: TxLogMode, format: Format, ) -> StorageResult<Self>

Create with a specific storage format.

pub fn with_storage( project_path: impl Into<PathBuf>, file_count: usize, mode: TxLogMode, storage: RyoStorage, ) -> Self

Create with explicit storage (for testing or custom paths).

pub fn format(&self) -> Format

Get the storage format.

pub fn mode(&self) -> TxLogMode

Get the current mode.

pub fn set_mode(&mut self, mode: TxLogMode)

Set the mode (can be changed at runtime).

pub fn log(&self, action: TxAction)

Log an action.

pub fn log_goal(&self, query: &str, intent_type: &str, confidence: f64)

Log a goal being set.

pub fn log_mutation( &mut self, mutation_type: &str, target: &str, changes: usize, ) -> StorageResult<()>

Log a mutation being applied (legacy API - NOT replayable).

Note: For replayable logging, use record_mutation() instead. If mode is OnMutation, this will trigger a persist.

pub fn record_mutation<M>( &mut self, mutation: &M, changes: usize, ) -> StorageResult<()>

where M: Mutation + ToSerializable,

Record a mutation with automatic serialization (REPLAYABLE).

This is the preferred method for logging mutations. If mode is OnMutation, this will trigger a persist.

pub fn record_mutation_for_file<M>( &mut self, mutation: &M, changes: usize, file_path: impl AsRef<Path>, ) -> StorageResult<()>

where M: Mutation + ToSerializable,

Record a mutation with file path (REPLAYABLE).

If mode is OnMutation, this will trigger a persist.

pub fn record_mutation_tracked<M>( &mut self, mutation: &M, changes: usize, file_path: impl AsRef<Path>, pre_state: StateRef, post_state: StateRef, ) -> StorageResult<()>

where M: Mutation + ToSerializable,

Record a mutation with full state tracking (REPLAYABLE + VERIFIABLE).

If mode is OnMutation, this will trigger a persist.

pub fn log_mutation_with_data( &mut self, mutation_type: &str, target: &str, changes: usize, data: Value, ) -> StorageResult<()>

Log a mutation with data.

pub fn log_mutation_batch( &mut self, mutations: Vec<MutationRecord>, total_changes: usize, ) -> StorageResult<()>

Log a batch of mutations.

pub fn log_file_loaded(&self, path: &Path, size_bytes: usize)

Log file loaded.

pub fn log_file_modified(&self, path: &Path, changes: usize)

Log file modified.

pub fn log_file_written(&self, path: &Path)

Log file written.

pub fn log_compile_check(&self, success: bool, errors: Vec<String>)

Log compile check result.

pub fn checkpoint(&self, name: &str)

Create a checkpoint.

pub fn log_undo(&self, target_id: u64)

Log an undo operation.

pub fn log_redo(&self, target_id: u64)

Log a redo operation.

pub fn log_custom(&self, name: &str, data: Value)

Log a custom action.

pub fn on_commit(&mut self) -> StorageResult<()>

Called when commit_changes() is invoked.

If mode is OnCommit, this will trigger a persist.

pub fn persist(&mut self) -> StorageResult<String>

Explicitly persist the current log to storage.

This can be called at any time, regardless of mode. Uses incremental save if session already has an ID.

pub fn finish(self) -> StorageResult<(TxLog, Option<String>)>

Finish logging and persist the final log.

Returns the complete log and the session ID if persisted.

pub fn finish_log(self) -> TxLog

Finish and return just the log (for compatibility).

pub fn elapsed_ms(&self) -> u64

Get elapsed time since session start.