use crate::args::Format;
use crate::cli::Output;
use crate::json::escape;
use crate::render::{Style, human};
use crate::session::{LoadEvent, Session};
use crate::tracecmd::value;
use std::collections::BTreeMap;
#[derive(Default)]
struct Raw {
session: Option<String>,
path: Option<String>,
top: Option<String>,
cost: bool,
model: Option<String>,
style: Style,
format: Format,
chdir: Option<String>,
}
pub(crate) struct Row {
pub(crate) what: String,
pub(crate) tokens: u64,
loads: usize,
stale: usize,
carried: u64,
}
pub(crate) fn top(rest: &[String]) -> Output {
match parse(rest) {
Ok(raw) => run(&raw),
Err(e) => Output::usage_err(format!("itok: {e}")),
}
}
fn run(raw: &Raw) -> Output {
let read = crate::tracecmd::session_with_compactions(
raw.session.as_deref(),
raw.chdir.as_deref(),
);
let (parsed, compactions, _) = match read {
Ok(v) => v,
Err(o) => return o,
};
render(raw, &parsed, &compactions)
}
fn render(
raw: &Raw,
parsed: &Session,
compactions: &[crate::session::Compaction],
) -> Output {
let cost = match cost_line(parsed, raw) {
Ok(line) => line,
Err(e) => return Output::usage_err(format!("itok: {e}")),
};
let rows = rank(parsed, raw);
let caveat = Caveat::of(compactions);
Output::ok(match raw.format {
Format::Json => json(&rows, parsed, caveat),
Format::Human => report(&rows, parsed, &raw.style, caveat) + &cost,
})
}
fn rank(parsed: &Session, raw: &Raw) -> Vec<Row> {
let events = filtered(&parsed.events, raw.path.as_deref());
let mut rows = group(&events, &turn_times(parsed));
rows.sort_by(|a, b| b.tokens.cmp(&a.tokens).then(a.what.cmp(&b.what)));
if let Some(n) = raw.top.as_ref().and_then(|n| n.parse::<usize>().ok()) {
rows.truncate(n);
}
rows
}
pub(crate) fn ranked(parsed: &Session) -> Vec<Row> {
let events: Vec<&LoadEvent> = parsed.events.iter().collect();
let mut rows = group(&events, &turn_times(parsed));
rows.sort_by(|a, b| b.tokens.cmp(&a.tokens).then(a.what.cmp(&b.what)));
rows
}
fn filtered<'a>(
events: &'a [LoadEvent],
want: Option<&str>,
) -> Vec<&'a LoadEvent> {
events
.iter()
.filter(|e| want.is_none_or(|p| e.path.as_deref() == Some(p)))
.collect()
}
fn turn_times(parsed: &Session) -> Vec<String> {
let mut ts: Vec<String> =
parsed.turns.iter().map(|t| t.ts.clone()).collect();
ts.sort();
ts
}
fn group(events: &[&LoadEvent], turns: &[String]) -> Vec<Row> {
let mut acc: BTreeMap<String, Sum> = BTreeMap::new();
for e in events {
acc.entry(identity(e)).or_default().absorb(e, turns);
}
acc.into_iter()
.map(|(what, s)| Row {
what,
tokens: s.tokens,
loads: s.loads,
stale: turns_after(turns, &s.last),
carried: s.carried,
})
.collect()
}
fn identity(e: &LoadEvent) -> String {
e.path
.clone()
.unwrap_or_else(|| format!("({})", e.source.label()))
}
#[derive(Default)]
struct Sum {
tokens: u64,
loads: usize,
last: String,
carried: u64,
}
impl Sum {
fn absorb(&mut self, e: &LoadEvent, turns: &[String]) {
let tokens = tokens_of(e.bytes);
self.tokens = self.tokens.saturating_add(tokens);
self.loads = self.loads.saturating_add(1);
let remaining = u64::try_from(turns_after(turns, &e.ts)).unwrap_or(0);
self.carried = self
.carried
.saturating_add(tokens.saturating_mul(remaining));
if e.ts > self.last {
self.last.clone_from(&e.ts);
}
}
}
fn tokens_of(bytes: usize) -> u64 {
u64::try_from(bytes / 4).unwrap_or(u64::MAX)
}
fn turns_after(turns: &[String], last: &str) -> usize {
turns.iter().filter(|t| t.as_str() > last).count()
}
fn report(
rows: &[Row],
parsed: &Session,
style: &Style,
caveat: Caveat<'_>,
) -> String {
let total: u64 = rows.iter().fold(0, |a, r| a.saturating_add(r.tokens));
let mut out = if style.summarize {
String::new()
} else {
rows.iter().map(|r| line(r, style)).collect()
};
out.push_str(&total_line(total, style));
if !style.summarize {
out.push_str(&caveat.legend());
}
out.push_str(&ledger(parsed, style));
out
}
fn money(parsed: &Session, rates: crate::models::Rates) -> Option<u64> {
let split = [
(parsed.fresh_input(), rates.input),
(parsed.cache_read(), rates.cache_read),
(parsed.cache_written(), rates.cache_write),
];
if split.iter().all(|(n, _)| n.is_none()) {
return None;
}
Some(split.iter().fold(0u64, |acc, (n, rate)| {
let part = n.unwrap_or(0).saturating_mul(*rate);
acc.saturating_add(part.checked_div(1_000_000).unwrap_or(0))
}))
}
fn cost_line(parsed: &Session, raw: &Raw) -> Result<String, String> {
if !raw.cost {
return Ok(String::new());
}
let Some(name) = raw.model.as_deref() else {
return Ok(
" cost: none -- pass --model X; rates are per model\n".to_owned()
);
};
let root = std::path::PathBuf::from(raw.chdir.as_deref().unwrap_or("."));
let rates = crate::models::tier(Some(name), &root)?.rates;
Ok(rates.map_or_else(
|| format!(" cost: none -- {name} declares no rate column\n"),
|r| cost_text(parsed, r),
))
}
fn cost_text(parsed: &Session, rates: crate::models::Rates) -> String {
money(parsed, rates).map_or_else(
|| " cost: none -- no usage recorded to price\n".to_owned(),
|n| {
format!(
"{n:>9} cost (declared units; \
in/cr/cc per 1M tokens)\n"
)
},
)
}
#[derive(Clone, Copy)]
pub(crate) struct Caveat<'a> {
first: Option<&'a str>,
count: usize,
}
impl<'a> Caveat<'a> {
pub(crate) fn of(compactions: &'a [crate::session::Compaction]) -> Self {
Self {
first: compactions.first().map(|c| c.ts.as_str()),
count: compactions.len(),
}
}
pub(crate) fn legend(&self) -> String {
let tail = self.first.map_or_else(
|| "assumes no compaction".to_owned(),
|ts| format!("UPPER BOUND -- this session compacted at {ts}"),
);
format!(
" carried = itok x turns since entry (cache re-billing; {tail})\n"
)
}
pub(crate) fn method(&self) -> &'static str {
if self.first.is_some() {
"bytes/4 x turns-since-entry (UPPER BOUND: this session compacted)"
} else {
"bytes/4 x turns-since-entry (assumes no compaction)"
}
}
}
fn ledger(parsed: &Session, style: &Style) -> String {
let Some(win) = parsed.window() else {
return String::new();
};
format!(
"\n{win:>9} itok window (actual, last turn)\n\
{acc:>9} itok accounted (bytes/4, {loads} loads)\n\
{gap:>9} itok unaccounted (system prompt + tool schemas + conversation)\n\
{billed:>9} itok billed (actual, {turns} turns)\n",
win = size(win, style),
acc = tilde(parsed.accounted_tokens(), style),
loads = parsed.events.len(),
gap = tilde(parsed.unaccounted_tokens().unwrap_or(0), style),
billed = size(parsed.billed_input(), style),
turns = parsed.turns.len(),
) + &cache_lines(parsed, style)
}
fn cache_lines(parsed: &Session, style: &Style) -> String {
[
("fresh", parsed.fresh_input()),
("cache write", parsed.cache_written()),
("cache read", parsed.cache_read()),
]
.iter()
.filter_map(|(label, v)| Some((label, (*v)?)))
.map(|(label, v)| format!("{:>19} itok {label}\n", size(v, style)))
.collect::<String>()
+ &cold_line(parsed, style)
}
fn cold_line(parsed: &Session, style: &Style) -> String {
let Some(cold) = parsed.cold_cache() else {
return String::new(); };
if cold.turns == 0 {
return String::new();
}
format!(
"{:>28} turn(s) re-wrote the prefix ({} written, {} read)\n",
cold.turns,
size(cold.written, style),
size(cold.read, style),
)
}
fn total_line(total: u64, style: &Style) -> String {
format!("{:>8} itok total (bytes/4)\n", tilde(total, style))
}
fn line(r: &Row, style: &Style) -> String {
format!(
"{:>6} {:>8} itok {:>6} {:>10} itok {}\n",
r.loads,
tilde(r.tokens, style),
r.stale,
tilde(r.carried, style),
r.what
)
}
fn tilde(n: u64, style: &Style) -> String {
format!("~{}", size(n, style))
}
fn size(n: u64, style: &Style) -> String {
if style.human { human(n) } else { n.to_string() }
}
fn json(rows: &[Row], parsed: &Session, caveat: Caveat<'_>) -> String {
let mut out: String = rows.iter().map(|r| json_object(r, caveat)).collect();
out.push_str(&json_summary(parsed, caveat));
out
}
fn json_counts(parsed: &Session) -> String {
format!(
"\"loads\":{},\"turns\":{},\"skipped\":{}",
parsed.events.len(),
parsed.turns.len(),
parsed.skipped,
)
}
fn json_cache(parsed: &Session) -> String {
let field =
|v: Option<u64>| v.map_or_else(|| "null".to_owned(), |n| n.to_string());
format!(
"\"fresh\":{},\"cache_write\":{},\"cache_read\":{},\
\"cold_cache_turns\":{},\"cold_cache_written\":{}",
field(parsed.fresh_input()),
field(parsed.cache_written()),
field(parsed.cache_read()),
field(parsed.cold_cache().map(|c| c.turns as u64)),
field(parsed.cold_cache().map(|c| c.written)),
)
}
fn json_summary(parsed: &Session, caveat: Caveat<'_>) -> String {
let Some(win) = parsed.window() else {
return String::new();
};
let counts = json_counts(parsed);
let cache = json_cache(parsed);
let gap = parsed.unaccounted_tokens().unwrap_or(0);
format!(
"{{\"summary\":true,\"window\":{win},\"accounted\":{acc},\
\"unaccounted\":{gap},\"billed\":{billed},{cache},{counts},\
\"compactions\":{n},\"unit\":\"input_tokens\",\
\"window_method\":\"actual\",\"accounted_method\":\"bytes/4\"}}\n",
acc = parsed.accounted_tokens(),
billed = parsed.billed_input(),
n = caveat.count,
)
}
fn json_object(r: &Row, caveat: Caveat<'_>) -> String {
format!(
"{{\"what\":\"{}\",\"tokens\":{},\"loads\":{},\"stale_turns\":{},\
\"carried\":{},\"carried_method\":\"{}\",\
\"unit\":\"input_tokens\",\"estimated\":true,\"method\":\"bytes/4\"}}\n",
escape(&r.what),
r.tokens,
r.loads,
r.stale,
r.carried,
caveat.method(),
)
}
fn parse(rest: &[String]) -> Result<Raw, String> {
let mut raw = Raw::default();
let mut it = rest.iter();
while let Some(a) = it.next() {
apply(a, &mut it, &mut raw)?;
}
Ok(raw)
}
fn apply<'a>(
a: &str,
it: &mut impl Iterator<Item = &'a String>,
raw: &mut Raw,
) -> Result<(), String> {
match a {
"-h" => raw.style.human = true,
"-s" => raw.style.summarize = true,
"--cost" => raw.cost = true,
"--bpe" | "--ollama" => {
return Err(crate::tracecmd::no_real_tier(a, "top"));
}
_ => return with_value(a, it, raw),
}
Ok(())
}
fn with_value<'a>(
a: &str,
it: &mut impl Iterator<Item = &'a String>,
raw: &mut Raw,
) -> Result<(), String> {
match a {
"--top" => raw.top = Some(value(it, a)?),
"--model" => raw.model = Some(value(it, a)?),
"-C" => raw.chdir = Some(value(it, a)?),
"--" => raw.path = Some(value(it, a)?),
"--format" => raw.format = crate::tracecmd::format_of(&value(it, a)?)?,
other if other.starts_with('-') => {
return Err(format!("unknown flag {other}"));
}
other => raw.session = Some(other.to_owned()),
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::session::claude_code;
fn fixture(name: &str) -> String {
format!(
"{}/tests/fixtures/session/{name}",
env!("CARGO_MANIFEST_DIR")
)
}
fn run_on(name: &str, extra: &[&str]) -> Output {
let mut args = vec![fixture(name)];
args.extend(extra.iter().map(|s| (*s).to_owned()));
top(&args)
}
fn rows_of(out: &Output) -> Vec<&str> {
out.out
.lines()
.take_while(|l| !l.contains("total (bytes/4)"))
.collect()
}
#[test]
fn rows_are_ranked_by_occupancy() {
let out = run_on("tool-shapes.jsonl", &[]);
let nums: Vec<u64> = rows_of(&out)
.iter()
.filter_map(|l| {
l.split('~').nth(1)?.split_whitespace().next()?.parse().ok()
})
.collect();
let mut sorted = nums.clone();
sorted.sort_by(|a, b| b.cmp(a));
assert_eq!(nums, sorted, "rows must descend by tokens");
}
#[test]
fn top_n_truncates_the_ranking() {
let all = run_on("tool-shapes.jsonl", &[]);
let two = run_on("tool-shapes.jsonl", &["--top", "2"]);
assert!(rows_of(&two).len() < rows_of(&all).len());
assert_eq!(rows_of(&two).len(), 2);
}
#[test]
fn summarize_drops_the_rows_but_keeps_the_ledger() {
let out = run_on("tool-shapes.jsonl", &["-s"]);
assert!(rows_of(&out).is_empty(), "no per-row lines under -s");
assert!(out.out.contains("total (bytes/4)"));
assert!(out.out.contains("unaccounted"));
}
#[test]
fn human_sizes_abbreviate() {
let plain = Style::default();
let big = Style {
human: true,
summarize: false,
};
assert_eq!(tilde(12_345, &plain), "~12345");
assert_eq!(tilde(12_345, &big), "~12k");
}
#[test]
fn a_path_filter_narrows_to_one_paths_loads() {
let out = run_on("tool-shapes.jsonl", &["--", "/w/one.txt"]);
let rows = rows_of(&out);
assert_eq!(rows.len(), 1, "one row for one path");
assert!(rows.first().is_some_and(|r| r.contains("/w/one.txt")));
}
#[test]
fn repeated_loads_are_counted() {
let out = run_on("tool-shapes.jsonl", &["--", "/w/one.txt"]);
let row = rows_of(&out).first().copied().unwrap_or_default();
let loads: usize = row
.split_whitespace()
.next()
.and_then(|n| n.parse().ok())
.unwrap_or(0);
assert_eq!(loads, 2, "read + edit = two loads of the same path");
}
#[test]
fn pathless_loads_group_under_their_source() {
let out = run_on("tool-shapes.jsonl", &[]);
assert!(out.out.contains("(shell)"));
}
#[test]
fn json_is_one_object_per_row() {
let out = run_on("tool-shapes.jsonl", &["--format", "json"]);
let human = rows_of(&run_on("tool-shapes.jsonl", &[])).len();
let rows = json_rows(&out);
assert_eq!(rows.len(), human, "one object per ranked row");
for line in rows {
assert!(line.contains("\"unit\":\"input_tokens\""));
assert!(line.contains("\"estimated\":true"));
assert!(line.contains("\"stale_turns\":"));
}
assert!(!out.out.contains('~'), "no tilde in a numeric field (V3)");
}
fn json_rows(out: &Output) -> Vec<&str> {
out.out
.lines()
.filter(|l| !l.contains("\"summary\":true"))
.collect()
}
#[test]
fn a_real_tier_is_refused() {
let out = run_on("tool-shapes.jsonl", &["--bpe"]);
assert_eq!(out.code, 2);
assert!(out.err.contains("no content is stored"));
assert!(out.err.contains("top"), "the message names the verb");
}
#[test]
fn a_named_miss_is_a_usage_error() {
let out = top(&["/nonexistent/s.jsonl".to_owned()]);
assert_eq!(out.code, 2, "a name that resolves to nothing");
assert!(out.out.is_empty(), "nothing on stdout");
assert!(out.err.contains("no session"), "{}", out.err);
}
#[test]
fn unknown_flags_and_bad_formats_are_usage_errors() {
assert_eq!(run_on("tool-shapes.jsonl", &["--nope"]).code, 2);
assert_eq!(run_on("tool-shapes.jsonl", &["--format", "yaml"]).code, 2);
assert_eq!(run_on("tool-shapes.jsonl", &["--top"]).code, 2);
}
#[test]
fn accounted_plus_unaccounted_is_the_window() {
let text = std::fs::read_to_string(fixture("minimal.jsonl"))
.unwrap_or_default();
let s = claude_code::parse(&text);
let win = s.window().unwrap_or(0);
let sum = s
.accounted_tokens()
.saturating_add(s.unaccounted_tokens().unwrap_or(0));
assert_eq!(sum, win);
}
#[test]
fn the_split_uses_one_window_not_the_cumulative_bill() {
let text = std::fs::read_to_string(fixture("minimal.jsonl"))
.unwrap_or_default();
let s = claude_code::parse(&text);
let win = s.window().unwrap_or(0);
assert!(
win <= s.billed_input(),
"a window can never exceed the cumulative bill"
);
assert!(
s.unaccounted_tokens().unwrap_or(u64::MAX) <= win,
"the gap is bounded by ONE window, not by the whole session"
);
}
#[test]
fn the_gap_is_marked_estimated() {
let out = run_on("minimal.jsonl", &["-s"]);
let gap = out
.out
.lines()
.find(|l| l.contains("unaccounted"))
.unwrap_or_default();
assert!(gap.contains('~'), "unaccounted must carry the tilde");
let win = out
.out
.lines()
.find(|l| l.contains("window"))
.unwrap_or_default();
assert!(!win.contains('~'), "the window is exact, no tilde");
}
#[test]
fn no_usage_reports_no_split_rather_than_zero() {
let out = run_on("tool-shapes.jsonl", &["-s"]);
assert!(out.out.contains("window"), "this fixture has usage");
let s = crate::session::Session::default();
assert_eq!(s.window(), None);
assert_eq!(s.unaccounted_tokens(), None);
}
#[test]
fn an_over_estimate_clamps_the_gap_at_zero() {
let mut s = crate::session::Session::default();
s.turns.push(crate::session::Turn {
cache_read: Some(10),
..crate::session::Turn::default()
});
s.events.push(crate::session::LoadEvent {
session: String::new(),
ts: String::new(),
source: crate::session::Source::Tool("shell".to_owned()),
path: None,
bytes: 4000,
spilled: None,
});
assert!(s.accounted_tokens() > s.window().unwrap_or(0));
assert_eq!(s.unaccounted_tokens(), Some(0), "clamped, never negative");
}
#[test]
fn the_json_summary_is_distinguishable_and_labelled() {
let out = run_on("minimal.jsonl", &["--format", "json"]);
let last = out.out.lines().last().unwrap_or_default();
assert!(last.contains("\"summary\":true"));
assert!(last.contains("\"window_method\":\"actual\""));
assert!(last.contains("\"accounted_method\":\"bytes/4\""));
assert!(!out.out.contains('~'), "no tilde in json (V9)");
}
#[test]
fn the_cache_parts_sum_to_billed() {
let text = std::fs::read_to_string(fixture("minimal.jsonl"))
.unwrap_or_default();
let s = claude_code::parse(&text);
let parts = s
.fresh_input()
.unwrap_or(0)
.saturating_add(s.cache_written().unwrap_or(0))
.saturating_add(s.cache_read().unwrap_or(0));
assert_eq!(parts, s.billed_input());
}
#[test]
fn cache_lines_appear_when_the_fields_are_present() {
let out = run_on("minimal.jsonl", &["-s"]);
for label in ["fresh", "cache write", "cache read"] {
assert!(out.out.contains(label), "missing `{label}` line");
}
}
#[test]
fn absent_cache_fields_produce_no_lines_and_no_zeros() {
let mut s = crate::session::Session::default();
s.turns.push(crate::session::Turn {
input: Some(100),
..crate::session::Turn::default()
});
assert_eq!(s.cache_read(), None, "never reported stays None");
let out = ledger(&s, &Style::default());
assert!(out.contains("fresh"), "the present field still shows");
assert!(!out.contains("cache read"), "absent field: no line");
assert!(!out.contains("cache write"), "absent field: no line");
}
#[test]
fn a_missing_field_does_not_suppress_a_present_one() {
let mut s = crate::session::Session::default();
s.turns.push(crate::session::Turn {
cache_read: Some(500),
..crate::session::Turn::default()
});
let out = ledger(&s, &Style::default());
assert!(out.contains("cache read"), "present field shows");
assert!(!out.contains("fresh"), "absent field stays absent");
}
#[test]
fn json_writes_null_for_an_absent_field_never_zero() {
let mut s = crate::session::Session::default();
s.turns.push(crate::session::Turn {
input: Some(7),
..crate::session::Turn::default()
});
let out = json_cache(&s);
assert!(out.contains("\"fresh\":7"));
assert!(out.contains("\"cache_read\":null"), "absent -> null");
assert!(!out.contains("\"cache_read\":0"), "never a zero");
}
#[test]
fn cache_figures_are_exact_not_estimated() {
let out = run_on("minimal.jsonl", &["-s"]);
let line = out
.out
.lines()
.find(|l| l.contains("cache read"))
.unwrap_or_default();
assert!(!line.contains('~'), "read from usage: no tilde");
}
#[test]
fn write_over_read_classifies_a_cold_turn() {
let mut s = crate::session::Session::default();
s.turns.push(turn_with(1_000, 600_000)); s.turns.push(turn_with(250_657, 20_628)); let cold = s.cold_cache().unwrap_or_default();
assert_eq!(cold.turns, 1, "only the write-heavy turn counts");
assert_eq!(cold.written, 250_657);
assert_eq!(cold.read, 20_628);
}
#[test]
fn equal_values_classify_as_neither() {
let mut s = crate::session::Session::default();
s.turns.push(turn_with(0, 0));
s.turns.push(turn_with(500, 500));
assert_eq!(s.cold_cache().unwrap_or_default().turns, 0);
}
#[test]
fn absent_cache_fields_cannot_be_classified() {
let mut s = crate::session::Session::default();
s.turns.push(crate::session::Turn {
input: Some(10),
..crate::session::Turn::default()
});
assert_eq!(s.cold_cache(), None, "cannot tell, not none-found");
assert!(cold_line(&s, &Style::default()).is_empty());
}
#[test]
fn no_cold_turns_means_no_line() {
let mut s = crate::session::Session::default();
s.turns.push(turn_with(1_000, 600_000));
assert_eq!(s.cold_cache().unwrap_or_default().turns, 0);
assert!(cold_line(&s, &Style::default()).is_empty());
}
#[test]
fn the_cold_line_reports_cost_without_cause_or_advice() {
let mut s = crate::session::Session::default();
s.turns.push(turn_with(250_657, 20_628));
let out = cold_line(&s, &Style::default());
assert!(out.contains("re-wrote the prefix"));
assert!(!out.contains('~'), "read from usage: exact");
for word in ["login", "auth", "avoid", "should", "consider"] {
assert!(
!out.to_lowercase().contains(word),
"no cause/advice: {word}"
);
}
}
#[test]
fn json_cold_fields_are_null_when_unclassifiable() {
let mut s = crate::session::Session::default();
s.turns.push(crate::session::Turn {
input: Some(1),
..crate::session::Turn::default()
});
let out = json_cache(&s);
assert!(out.contains("\"cold_cache_turns\":null"));
assert!(!out.contains("\"cold_cache_turns\":0"));
}
fn turn_with(write: u64, read: u64) -> crate::session::Turn {
crate::session::Turn {
cache_creation: Some(write),
cache_read: Some(read),
..crate::session::Turn::default()
}
}
fn carried_cell(out: &Output) -> &str {
rows_of(out)
.first()
.and_then(|r| r.split_whitespace().nth(4))
.unwrap_or_default()
}
#[test]
fn carried_is_size_times_turns_after_entry() {
let out = run_on("tool-shapes.jsonl", &["--", "/w/one.txt"]);
assert_eq!(carried_cell(&out), "~2");
}
#[test]
fn the_last_load_has_carried_nothing() {
let out = run_on("tool-shapes.jsonl", &["--", "/w/two.txt"]);
assert_eq!(carried_cell(&out), "~0");
}
#[test]
fn carried_charges_each_load_from_its_own_entry() {
let turns: Vec<String> = ["01", "03", "05", "07"]
.iter()
.map(|t| (*t).into())
.collect();
let mut sum = Sum::default();
sum.absorb(&load_at("02", 4000), &turns); sum.absorb(&load_at("04", 4000), &turns); assert_eq!(sum.tokens, 2000);
assert_eq!(sum.carried, 5000);
let shortcut = sum.tokens * 3;
assert_ne!(sum.carried, shortcut, "the summed-total product inflates");
}
fn load_at(ts: &str, bytes: usize) -> LoadEvent {
LoadEvent {
session: String::new(),
ts: ts.to_owned(),
source: crate::session::Source::Tool("Read".to_owned()),
path: Some("/w/one.txt".to_owned()),
bytes,
spilled: None,
}
}
#[test]
fn the_report_states_the_uncompacted_caveat() {
let out = run_on("tool-shapes.jsonl", &[]);
assert!(out.out.contains("carried = itok x turns since entry"));
assert!(out.out.contains("assumes no compaction"));
}
#[test]
fn money_prices_each_half_of_the_split_at_its_own_rate() {
let session = priced_session();
let rates = crate::models::Rates {
input: 300,
cache_read: 30,
cache_write: 375,
};
assert_eq!(money(&session, rates), Some(510));
}
#[test]
fn a_session_with_no_usage_has_no_price_rather_than_zero() {
let rates = crate::models::Rates {
input: 300,
cache_read: 30,
cache_write: 375,
};
assert_eq!(money(&Session::default(), rates), None);
}
#[test]
fn every_absent_price_names_its_own_reason() {
let session = priced_session();
let asked = Raw {
cost: true,
..Raw::default()
};
let out = cost_line(&session, &asked).unwrap_or_default();
assert!(out.contains("pass --model"), "{out}");
assert!(
cost_line(&session, &Raw::default())
.unwrap_or_default()
.is_empty()
);
}
#[test]
fn an_unknown_model_fails_rather_than_pricing_nothing() {
let asked = Raw {
cost: true,
model: Some("nonesuch".to_owned()),
chdir: Some("/nonexistent".to_owned()),
..Raw::default()
};
assert!(cost_line(&priced_session(), &asked).is_err());
}
fn priced_session() -> Session {
Session {
turns: vec![crate::session::Turn {
input: Some(1_000_000),
cache_read: Some(2_000_000),
cache_creation: Some(400_000),
..crate::session::Turn::default()
}],
..Session::default()
}
}
#[test]
fn the_carried_column_gives_no_advice() {
let compacted = Caveat {
first: Some("2026-08-16T05:19:24.283Z"),
count: 1,
};
let both = Caveat::of(&[]).legend() + &compacted.legend();
for word in ["should", "consider", "unhealthy", "reduce", "too"] {
assert!(!both.to_lowercase().contains(word), "no advice: {word}");
}
}
#[test]
fn a_compacted_session_labels_carried_an_upper_bound() {
let caveat = Caveat {
first: Some("2026-08-16T05:19:24.283Z"),
count: 2,
};
let legend = caveat.legend();
assert!(legend.contains("UPPER BOUND"), "{legend}");
assert!(legend.contains("2026-08-16T05:19:24.283Z"), "{legend}");
assert!(!legend.contains("assumes no compaction"), "{legend}");
assert!(
caveat.method().contains("UPPER BOUND"),
"{}",
caveat.method()
);
}
#[test]
fn a_session_that_never_compacted_keeps_the_exact_reading() {
let caveat = Caveat::of(&[]);
assert!(caveat.legend().contains("assumes no compaction"));
assert!(!caveat.legend().contains("UPPER BOUND"));
assert!(caveat.method().contains("assumes no compaction"));
}
#[test]
fn the_caveat_is_absent_when_no_rows_are_shown() {
let out = run_on("tool-shapes.jsonl", &["-s"]);
assert!(!out.out.contains("carried ="));
}
#[test]
fn carried_keeps_the_tilde_and_json_does_not() {
assert!(carried_cell(&run_on("tool-shapes.jsonl", &[])).contains('~'));
let out = run_on("tool-shapes.jsonl", &["--format", "json"]);
assert!(!out.out.contains('~'));
}
#[test]
fn json_rows_carry_the_leverage_field_and_its_method() {
let out = run_on("tool-shapes.jsonl", &["--format", "json"]);
for line in json_rows(&out) {
assert!(line.contains("\"carried\":"));
assert!(line.contains("\"carried_method\":\"bytes/4 x turns"));
assert!(line.contains("(assumes no compaction)"));
assert!(line.contains("\"stale_turns\":"));
assert!(line.contains("\"tokens\":"));
}
}
#[test]
fn stale_counts_turns_after_the_last_load() {
let out = run_on("tool-shapes.jsonl", &["--", "/w/two.txt"]);
let row = rows_of(&out).first().copied().unwrap_or_default();
let stale: usize = row
.split_whitespace()
.nth(3)
.and_then(|n| n.parse().ok())
.unwrap_or(999);
assert_eq!(stale, 0, "the last-loaded path has no turns after it");
}
}