Struct ProgressEngine 

pub struct ProgressEngine<'a> { /* private fields */ }

Progress management workflow engine.

Implementations

impl<'a> ProgressEngine<'a>

pub async fn reset_deck(&self, deck: &str) -> Result<ResetReport>

Reset all cards in a deck to new state.

This clears all learning progress for the deck.

Arguments

• deck - Name of the deck to reset

Example

let engine = Engine::new();
let report = engine.progress().reset_deck("Test Deck").await?;
println!("Reset {} cards", report.cards_reset);

pub async fn tag_by_performance( &self, query: &str, criteria: PerformanceCriteria, struggling_tag: &str, mastered_tag: &str, ) -> Result<TagReport>

Tag cards based on their performance.

Cards are categorized as “struggling” or “mastered” based on ease factor, lapse count, and review count.

Arguments

• query - Anki search query to filter cards
• criteria - Criteria for categorization
• struggling_tag - Tag to apply to struggling cards
• mastered_tag - Tag to apply to mastered cards

Example

let engine = Engine::new();
let report = engine.progress()
    .tag_by_performance(
        "deck:Japanese",
        PerformanceCriteria::default(),
        "struggling",
        "mastered"
    )
    .await?;
println!("{} struggling, {} mastered", report.struggling_count, report.mastered_count);

pub async fn suspend_by_criteria( &self, query: &str, criteria: SuspendCriteria, ) -> Result<SuspendReport>

Suspend cards matching performance criteria.

Arguments

• query - Anki search query to filter cards
• criteria - Criteria for suspension

Example

let engine = Engine::new();
let report = engine.progress()
    .suspend_by_criteria("deck:Japanese", SuspendCriteria::default())
    .await?;
println!("Suspended {} cards", report.cards_suspended);

pub async fn deck_health(&self, deck: &str) -> Result<HealthReport>

Get comprehensive health report for a deck.

Arguments

• deck - Deck name to analyze

Example

let engine = Engine::new();
let report = engine.progress().deck_health("Japanese").await?;
println!("Total: {}, Suspended: {}, Leeches: {}",
    report.total_cards, report.suspended_cards, report.leech_count);

pub async fn bulk_tag( &self, query: &str, operation: TagOperation, ) -> Result<BulkTagReport>

Perform bulk tag operation on notes matching a query.

Arguments

• query - Anki search query to filter notes
• operation - Tag operation to perform

Example

let engine = Engine::new();

// Add tags
let report = engine.progress()
    .bulk_tag("deck:Japanese", TagOperation::Add("needs-review".to_string()))
    .await?;

// Remove tags
let report = engine.progress()
    .bulk_tag("deck:Japanese", TagOperation::Remove("old-tag".to_string()))
    .await?;

// Replace tags
let report = engine.progress()
    .bulk_tag("deck:Japanese", TagOperation::Replace {
        old: "v1".to_string(),
        new: "v2".to_string(),
    })
    .await?;

pub async fn smart_suspend( &self, query: &str, criteria: SimilarityCriteria, ) -> Result<SmartSuspendReport>

Suspend similar cards to reduce interference during learning.

This workflow analyzes cards for content similarity and suspends all but one card from each group of similar cards.

Arguments

• query - Anki search query to filter cards
• criteria - Similarity criteria and options

Example

let engine = Engine::new();

// First do a dry run to see what would be suspended
let report = engine.progress()
    .smart_suspend("deck:Japanese", SimilarityCriteria {
        threshold: 0.85,
        field: "Front".to_string(),
        keep_strategy: KeepStrategy::MostMature,
        dry_run: true,
    })
    .await?;

println!("Would suspend {} cards in {} groups",
    report.cards_suspended, report.groups_found);

// Then actually suspend
let report = engine.progress()
    .smart_suspend("deck:Japanese", SimilarityCriteria {
        dry_run: false,
        ..SimilarityCriteria::default()
    })
    .await?;

Trait Implementations

impl<'a> Debug for ProgressEngine<'a>

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

Formats the value using the given formatter.