overbrainer 0.10.0

Distill a large LLM into a smaller open-weights model: generate questions, collect answers, fine-tune, visualize.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

//! The `overbrainer history` subcommand.

use std::path::Path;

use anyhow::Context as _;

use super::HistoryArgs;
use crate::history::{self, Cost, Entry, Total};

/// Prints the totals per stage and overall, or with `--all` every execution.
///
/// # Errors
///
/// Returns an error when the history exists but cannot be read.
pub fn run(project_dir: &Path, args: &HistoryArgs) -> anyhow::Result<()> {
    let entries = history::read(project_dir)
        .with_context(|| format!("cannot read {}", history::path(project_dir).display()))?;
    if entries.is_empty() {
        println!("no stage has run yet");
        return Ok(());
    }
    if args.all {
        for entry in &entries {
            println!("{}", entry_line(entry));
        }
        return Ok(());
    }
    let (per_stage, all) = history::totals(&entries);
    for (stage, total) in &per_stage {
        println!("{}", total_line(stage.name(), total));
    }
    println!("{}", total_line("total", &all));
    Ok(())
}

fn total_line(name: &str, total: &Total) -> String {
    format!(
        "{name:<9}  {} run(s), {} done, {} failed; tokens {} in, {} out; {}",
        total.runs, total.done, total.failed, total.input_tokens, total.output_tokens, total.cost
    )
}

fn entry_line(entry: &Entry) -> String {
    if let Some(split) = &entry.split {
        return format!(
            "{}  {:<9}  {:<11}  train {}, eval {}, excluded {}, orphaned {}",
            entry.started_at,
            entry.stage.name(),
            entry.status.name(),
            split.train,
            split.eval,
            entry.excluded,
            split.orphaned,
        );
    }
    let model = entry.model.as_deref().unwrap_or("-");
    let cost = entry.cost.map_or(Cost::Unknown, Cost::Known);
    let note = if entry.backfilled {
        " (backfilled)"
    } else {
        ""
    };
    format!(
        "{}  {:<9}  {:<11}  {model}  {} done, {} skipped, {} failed, {} excluded; tokens {} in, {} out; {cost}{note}",
        entry.started_at,
        entry.stage.name(),
        entry.status.name(),
        entry.done,
        entry.skipped,
        entry.failed,
        entry.excluded,
        entry.input_tokens,
        entry.output_tokens,
    )
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::events::Stage;
    use crate::history::Status;

    #[test]
    fn a_backfilled_entry_says_so() {
        let mut entry = Entry {
            stage: Stage::Answers,
            started_at: "2026-09-27T10:00:00Z".into(),
            ended_at: "2026-09-27T10:00:00Z".into(),
            status: Status::Ok,
            provider: None,
            model: Some("parent".into()),
            done: 3,
            skipped: 0,
            failed: 0,
            excluded: 1,
            input_tokens: 30,
            output_tokens: 15,
            cost: None,
            split: None,
            backfilled: false,
        };
        assert!(!entry_line(&entry).contains("backfilled"));
        entry.backfilled = true;
        assert!(
            entry_line(&entry).ends_with("cost unknown (backfilled)"),
            "{}",
            entry_line(&entry)
        );
    }
}