Struct IncrementalAnalyzer 

pub struct IncrementalAnalyzer { /* private fields */ }

Core incremental analysis coordinator.

Manages the dependency graph, storage backend, and coordinates change detection, invalidation, and reanalysis workflows.

Examples

use thread_flow::incremental::analyzer::IncrementalAnalyzer;
use thread_flow::incremental::storage::InMemoryStorage;

let storage = Box::new(InMemoryStorage::new());
let mut analyzer = IncrementalAnalyzer::new(storage);

Implementations

impl IncrementalAnalyzer

pub fn new(storage: Box<dyn StorageBackend>) -> Self

Creates a new incremental analyzer with the given storage backend.

Initializes with an empty dependency graph. To restore a previous session, use IncrementalAnalyzer::from_storage instead.

Arguments

• storage - The storage backend to use for persistence.

Examples

let storage = Box::new(InMemoryStorage::new());
let analyzer = IncrementalAnalyzer::new(storage);

pub async fn from_storage( storage: Box<dyn StorageBackend>, ) -> Result<Self, AnalyzerError>

Creates a new incremental analyzer and loads the dependency graph from storage.

This is the recommended way to initialize an analyzer for session continuity, as it restores the previous dependency graph state.

Arguments

• storage - The storage backend containing the previous session’s graph.

Errors

Returns AnalyzerError::Storage if loading the graph fails.

Examples

let storage = Box::new(PostgresStorage::new(config).await?);
let analyzer = IncrementalAnalyzer::from_storage(storage).await?;

pub async fn analyze_changes( &mut self, paths: &[PathBuf], ) -> Result<AnalysisResult, AnalyzerError>

Analyzes a set of files to detect changes.

Compares current file fingerprints with stored fingerprints to identify which files have been added or modified. Uses Blake3-based content hashing for fast change detection.

Performance: Achieves <10ms overhead for 100 files with >90% cache hit rate.

Arguments

• paths - Slice of file paths to analyze for changes.

Returns

An AnalysisResult containing changed files and performance metrics.

Errors

• AnalyzerError::Io if file reading fails
• AnalyzerError::Storage if fingerprint loading fails

Examples

let result = analyzer.analyze_changes(&[
    PathBuf::from("src/main.rs"),
    PathBuf::from("src/utils.rs"),
]).await?;

println!("Changed: {} files", result.changed_files.len());
println!("Cache hit rate: {:.1}%", result.cache_hit_rate * 100.0);

pub async fn invalidate_dependents( &self, changed: &[PathBuf], ) -> Result<Vec<PathBuf>, AnalyzerError>

Finds all files affected by changes to the given files.

Uses BFS traversal of the dependency graph to identify all files that transitively depend on the changed files. Only follows strong dependency edges (Import, Trait, Macro) for cascading invalidation.

Performance: O(V + E) where V = files, E = dependency edges. Achieves <5ms for 1000-node graphs.

Arguments

• changed - Slice of file paths that have changed.

Returns

A vector of all affected file paths (including the changed files themselves).

Errors

Returns AnalyzerError::Graph if graph traversal fails.

Examples

let changed = vec![PathBuf::from("src/utils.rs")];
let affected = analyzer.invalidate_dependents(&changed).await?;

println!("Files requiring reanalysis: {}", affected.len());

pub async fn reanalyze_invalidated( &mut self, files: &[PathBuf], ) -> Result<(), AnalyzerError>

Reanalyzes invalidated files and updates the dependency graph.

Performs dependency extraction for all affected files, updates their fingerprints, and saves the new state to storage. Files are processed in topological order (dependencies before dependents) to ensure correctness.

Error Recovery: Skips files that fail extraction but continues processing other files. Extraction errors are logged but do not abort the entire batch.

Arguments

• files - Slice of file paths requiring reanalysis.

Errors

• AnalyzerError::Storage if persistence fails
• AnalyzerError::Graph if topological sort fails (cyclic dependency)

Examples

let affected = analyzer.invalidate_dependents(&changed_files).await?;
analyzer.reanalyze_invalidated(&affected).await?;

pub fn graph(&self) -> &DependencyGraph

Returns a reference to the internal dependency graph.

Examples

let graph = analyzer.graph();
println!("Graph has {} nodes and {} edges",
    graph.node_count(), graph.edge_count());

pub fn graph_mut(&mut self) -> &mut DependencyGraph

Returns a mutable reference to the internal dependency graph.

Examples

let graph = analyzer.graph_mut();
graph.add_edge(edge);

pub async fn persist(&self) -> Result<(), AnalyzerError>

Persists the current dependency graph to storage.

Errors

Returns AnalyzerError::Storage if persistence fails.

Examples

analyzer.persist().await?;