Struct SessionParseState 

pub struct SessionParseState {

    pub mode: ParseMode,
    pub write_details: Vec<CodeAnalysisWriteDetail>,
    pub read_details: Vec<CodeAnalysisReadDetail>,
    pub edit_details: Vec<CodeAnalysisApplyDiffDetail>,
    pub run_details: Vec<CodeAnalysisRunCommandDetail>,
    pub tool_counts: CodeAnalysisToolCalls,
    pub unique_files: FastHashSet<String>,
    pub total_write_lines: usize,
    pub total_read_lines: usize,
    pub total_edit_lines: usize,
    pub total_write_characters: usize,
    pub total_read_characters: usize,
    pub total_edit_characters: usize,
    pub folder_path: String,
    pub git_remote: String,
    pub task_id: String,
    pub last_ts: i64,
}

Common parse state shared by all per-provider session parsers.

Construct with SessionParseState::new (full detail) or SessionParseState::with_mode, populate the metadata fields (folder_path, git_remote, task_id) directly as the provider header is read, feed file operations through the add_* helpers, then call SessionParseState::into_record to produce the final CodeAnalysisRecord. Not thread-safe; one instance parses one file on one thread.

Fields

mode: ParseMode

Detail-retention level chosen at construction.

write_details: Vec<CodeAnalysisWriteDetail>

Per-Write detail records (empty in ParseMode::UsageOnly).

read_details: Vec<CodeAnalysisReadDetail>

Per-Read detail records (empty in ParseMode::UsageOnly).

edit_details: Vec<CodeAnalysisApplyDiffDetail>

Per-Edit/diff detail records (empty in ParseMode::UsageOnly).

run_details: Vec<CodeAnalysisRunCommandDetail>

Per-Bash/run-command detail records (empty in ParseMode::UsageOnly).

tool_counts: CodeAnalysisToolCalls

Running per-tool call counts (always tallied, both modes).

unique_files: FastHashSet<String>

Distinct normalized file paths touched (populated in both parse modes).

total_write_lines: usize

Sum of lines written across all Write operations.

total_read_lines: usize

Sum of lines read across all Read operations.

total_edit_lines: usize

Sum of new-content lines across all Edit operations.

total_write_characters: usize

Sum of characters written across all Write operations.

total_read_characters: usize

Sum of characters read across all Read operations.

total_edit_characters: usize

Sum of new-content characters across all Edit operations.

folder_path: String

Session working directory; used to resolve relative paths to absolute.

git_remote: String

Git remote URL for the session’s repository, when known.

task_id: String

Provider-specific session identifier.

last_ts: i64

Latest event timestamp seen, in epoch milliseconds.

Implementations

impl SessionParseState

pub fn new() -> Self

Creates an empty parse state in ParseMode::Full.

Examples

use vct_core::session::state::SessionParseState;

let mut state = SessionParseState::new();
state.folder_path = "/repo".to_string();
state.add_read_detail("src/main.rs", "fn main() {}\n", 0);
assert_eq!(state.total_read_lines, 1);
assert_eq!(state.tool_counts.read, 1);

pub fn with_mode(mode: ParseMode) -> Self

Creates an empty parse state with the given detail-retention mode.

In ParseMode::Full the detail Vecs are pre-sized to typical session sizes. unique_files is pre-sized in both modes because total_unique_files is a scalar total that must stay exact.

pub fn add_read_detail(&mut self, path: &str, content: &str, ts: i64)

Records a Read operation against path with the read content.

Trailing newlines are stripped before counting. No-op (and no count bump) when the trimmed content is empty or when path normalizes to an empty string. The detail record is only stored in ParseMode::Full; counts and unique-file tracking accrue in both modes.

pub fn add_write_detail(&mut self, path: &str, content: &str, ts: i64)

Records a Write operation against path with the written content.

Trailing newlines are stripped before counting. No-op when path normalizes to an empty string (an empty body is still counted as a zero-line write). The full detail (including content) is stored only in ParseMode::Full; unique-file tracking remains active in both modes.

pub fn add_edit_detail(&mut self, path: &str, old: &str, new: &str, ts: i64)

Records an Edit operation against path, replacing old with new.

When old is empty but new is not, the edit is reclassified as a Write (a new-file creation expressed as a diff) and forwarded to SessionParseState::add_write_detail. Otherwise delegates to SessionParseState::add_edit_detail_raw.

pub fn add_edit_detail_raw(&mut self, path: &str, old: &str, new: &str, ts: i64)

Records an Edit operation against path without the new-file reclassification in SessionParseState::add_edit_detail.

Used for patch hunks that update an existing file, where an empty old just means an insert-only hunk. The line/character tally is taken from the trimmed new content. No-op when path normalizes to an empty string; full detail stored only in ParseMode::Full.

pub fn add_run_command(&mut self, command: &str, description: &str, ts: i64)

Records a Bash/run-command invocation with its command text.

No-op (and no count bump) when command is empty after trimming. The detail record (attributed to folder_path) is stored only in ParseMode::Full; the bash count accrues in both modes.

pub fn normalize_path(&self, path: &str) -> String

Resolves path to an absolute path, joining it onto folder_path.

Returns the input unchanged when it is already absolute, when it is empty, or when folder_path is empty (nothing to join against).

pub fn merge(&mut self, other: Self)

Merges another accumulator created with the same parse mode.

This is used when a provider must deduplicate message revisions before producing one session record. Detail vectors remain empty in ParseMode::UsageOnly, while scalar totals and unique paths are combined in both modes.

pub fn into_record( self, conversation_usage: FastHashMap<String, Value>, ) -> CodeAnalysisRecord

Consumes the state into a finished CodeAnalysisRecord.

conversation_usage is the per-model token map the provider parser accumulated separately; it is folded into the record verbatim.

Trait Implementations

impl Default for SessionParseState

fn default() -> Self

Equivalent to SessionParseState::new (ParseMode::Full).