@archeagle087/costcrew 0.0.0-stage → 0.4.0

package/src/args.rs

@@ -0,0 +1,239 @@
+//! Simple arg parsing — no clap, keep the binary lean.
+
+#[derive(Debug)]
+pub struct Args {
+    pub cmd: Cmd,
+    pub json: bool,
+    pub since_days: u32,
+    pub help: bool,
+    pub key: Option<String>,
+    pub prices: Option<String>,
+    pub sort: Option<String>,
+    pub top: usize,
+    /// positional words after the command ("prices claude", "spend add 20")
+    pub pos: Vec<String>,
+    pub service: Option<String>,
+    pub model: Option<String>,
+    pub note: Option<String>,
+    pub at: Option<String>,
+}
+
+#[derive(Debug, PartialEq)]
+pub enum Cmd {
+    Overview,
+    Scan,
+    Demo,
+    Md,
+    Advise,
+    Catalog,
+    Leaderboard,
+    OpenRouter,
+    Prices,
+    Spend,
+    SpendAdd,
+    Fetch,
+}
+
+/// two-word commands, checked before single-word matching
+pub fn split_cmd(argv: &[String]) -> Option<(Cmd, &[String])> {
+    if argv.len() >= 2 {
+        match (argv[0].as_str(), argv[1].as_str()) {
+            ("spend", "add") | ("s", "add") => return Some((Cmd::SpendAdd, &argv[2..])),
+            _ => {}
+        }
+    }
+    None
+}
+
+pub fn parse(argv: &[String]) -> Result<Args, String> {
+    if let Some((sub, rest)) = split_cmd(argv) {
+        let mut args = def(sub);
+        parse_into(&mut args, rest)?;
+        return Ok(args);
+    }
+    let mut args = def(Cmd::Overview);
+    parse_inner(&mut args, argv, &mut false)?; // commands may set cmd; default overview
+    if args.help {
+        print_help();
+        std::process::exit(0);
+    }
+    Ok(args)
+}
+
+fn def(cmd: Cmd) -> Args {
+    Args {
+        cmd,
+        json: false,
+        since_days: 30,
+        help: false,
+        key: None,
+        prices: None,
+        sort: None,
+        top: 25,
+        pos: Vec::new(),
+        service: None,
+        model: None,
+        note: None,
+        at: None,
+    }
+}
+
+fn parse_into(args: &mut Args, argv: &[String]) -> Result<(), String> {
+    let mut seen_cmd = true; // command already consumed ("spend add X")
+    parse_inner(args, argv, &mut seen_cmd)
+}
+
+pub fn parse_inner(args: &mut Args, argv: &[String], seen_cmd: &mut bool) -> Result<(), String> {
+    let mut it = argv.iter();
+    while let Some(a) = it.next() {
+        match a.as_str() {
+            "prices" | "db" if !*seen_cmd => {
+                args.cmd = Cmd::Prices;
+                *seen_cmd = true;
+            }
+            "spend" if !*seen_cmd => {
+                args.cmd = Cmd::Spend;
+                *seen_cmd = true;
+            }
+            "scan" | "c" if !*seen_cmd => {
+                args.cmd = Cmd::Scan;
+                *seen_cmd = true;
+            }
+            "demo" | "d" if !*seen_cmd => {
+                args.cmd = Cmd::Demo;
+                *seen_cmd = true;
+            }
+            "md" if !*seen_cmd => {
+                args.cmd = Cmd::Md;
+                *seen_cmd = true;
+            }
+            "advise" | "a" if !*seen_cmd => {
+                args.cmd = Cmd::Advise;
+                *seen_cmd = true;
+            }
+            "leaderboard" | "lb" | "board" if !*seen_cmd => {
+                args.cmd = Cmd::Leaderboard;
+                *seen_cmd = true;
+            }
+            "catalog" if !*seen_cmd => {
+                args.cmd = Cmd::Catalog;
+                *seen_cmd = true;
+            }
+            "openrouter" | "or" if !*seen_cmd => {
+                args.cmd = Cmd::OpenRouter;
+                *seen_cmd = true;
+            }
+            "fetch-prices" if !*seen_cmd => {
+                args.cmd = Cmd::Fetch;
+                *seen_cmd = true;
+            }
+            "--json" => args.json = true,
+            "--sort" => {
+                args.sort = Some(it.next().ok_or("--sort needs a value")?.to_string());
+            }
+            "--top" => {
+                let v = it.next().ok_or("--top needs a number")?;
+                args.top = v
+                    .parse()
+                    .map_err(|_| format!("--top must be a number, got {v}"))?;
+            }
+            "--service" => {
+                args.service = Some(it.next().ok_or("--service needs a value")?.to_string());
+            }
+            "--model" => {
+                args.model = Some(it.next().ok_or("--model needs a value")?.to_string());
+            }
+            "--note" => {
+                args.note = Some(it.next().ok_or("--note needs a value")?.to_string());
+            }
+            "--at" => {
+                args.at = Some(it.next().ok_or("--at needs YYYY-MM-DD")?.to_string());
+            }
+            "--help" | "-h" | "help" => args.help = true,
+            "--version" | "-V" | "-v" => {
+                println!("costcrew {}", env!("CARGO_PKG_VERSION"));
+                std::process::exit(0);
+            }
+            "--key" => {
+                args.key = Some(it.next().ok_or("--key needs a value")?.to_string());
+            }
+            "--prices" => {
+                args.prices = Some(it.next().ok_or("--prices needs a path")?.to_string());
+            }
+            "--since" => {
+                let v = it.next().ok_or("--since needs a value like 7d")?;
+                args.since_days = parse_since(v)?;
+            }
+            _ => {
+                if let Some(rest) = a.strip_prefix("--since=") {
+                    args.since_days = parse_since(rest)?;
+                } else if a.starts_with('-') {
+                    return Err(format!("unknown argument: {a}\ntry `costcrew --help`"));
+                } else if a == "add" && args.cmd == Cmd::Spend {
+                    // tolerate `costcrew spend add 20` ordering variants
+                } else {
+                    args.pos.push(a.to_string());
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+fn parse_since(v: &str) -> Result<u32, String> {
+    let v = v.trim().to_lowercase();
+    let (num, unit) = v.split_at(v.len().saturating_sub(1));
+    let n: u32 = num.parse().map_err(|_| format!("bad --since value: {v}"))?;
+    match unit {
+        "d" => Ok(n.max(1)),
+        "w" => Ok(n * 7),
+        "m" => Ok(n * 30),
+        _ => Err(format!("--since units are d/w/m, got: {v}")),
+    }
+}
+
+pub fn print_help() {
+    println!(
+        "costcrew {} — the AI coding price database, plus your spend
+
+USAGE — THE DATABASE:
+    costcrew                     opens the interactive app (splash + menu);
+                                 any argument instead uses classic flag mode
+    costcrew prices [filter]     browse {} models (bundled, offline):
+                                 every input/output/cache rate per 1M tokens
+                                 --sort name|price|cheap  --top N  --json
+    costcrew leaderboard         arena Elo ranked with prices:
+                                 --sort elo|value|price  --top N  --json
+    costcrew catalog             which agent ships with which models
+    costcrew fetch-prices        refresh the DB from OpenRouter live
+                                 (cached at %LOCALAPPDATA%\\costcrew)
+
+USAGE — YOUR SPEND:
+    costcrew spend               what YOU pay for AI: monthly totals,
+                                 per-service breakdown (you record it)
+    costcrew spend add 19.99     record a payment:
+                                 --service \"Claude Pro\" --model opus
+                                 --note \"monthly\" --at 2026-11-10
+    costcrew openrouter          actual per-model spend from an API key
+                                 (env OPENROUTER_API_KEY or --key sk-or-v1-...)
+
+USAGE — OPTIONAL ESTIMATES:
+    costcrew [scan]              estimate per-token cost from local agent logs
+    costcrew advise              could you have used a cheaper model? verdicts
+    costcrew md > report.md      shareable markdown report
+    costcrew demo                sample report from synthetic data
+
+FLAGS:
+    --since <Nd|Nw|Nm>           lookback for scan/advise/spend (default 30d)
+    --prices <file.json>         custom price overrides, e.g. a rented GPU:
+                                 [{{\"prefix\":\"local/llama-3\",\"per_hour\":2.19}}]
+                                 per_hour bills wall-clock (opencode logs the ms)
+    --json                       machine-readable output
+    -h, --help                   this help
+
+UNKNOWN PRICES STAY '?':
+    the database never invents a number — a free/unpriced model shows ?",
+        env!("CARGO_PKG_VERSION"),
+        509,
+    );
+}

package/src/board.rs

@@ -0,0 +1,227 @@
+//! `costcrew leaderboard` — arena-style model ranking, priced.
+//!
+//! Scores: bundled snapshot of LMArena's Coding category (blind pairwise votes,
+//! Bradley-Terry/Elo). Prices: merged from the built-in table + the cached
+//! OpenRouter list (see `costcrew fetch-prices`).
+//!
+//! The value column is tuned for how coding AGENTS actually burn tokens:
+//! agent_blend = 0.2·input + 0.1·output + 0.7·cache_read (per 1M tokens),
+//! from real OpenCode session mixes (cache dwarfs everything in agentic loops).
+//! value = (elo − 1400) / agent_blend  → points per dollar.
+
+use crate::price::PriceDB;
+use crate::report::{BOLD, DIM, GREEN, RED, RESET, YELLOW};
+
+pub struct BoardEntry {
+    /// prefix that must resolve through the price DB
+    pub prefix: &'static str,
+    pub display: &'static str,
+    pub elo: f64,
+    pub votes: u64,
+}
+
+/// Snapshot: LMArena Coding category, Nov 2026 (~2.0M votes). Best-effort row
+/// per model (highest reasoning effort). Elo only — margins are ±4–19 pts.
+#[rustfmt::skip]
+static BOARD: &[BoardEntry] = &[
+    BoardEntry { prefix: "gemini-4-carbon",     display: "Gemini 4 Carbon   · Google",      elo: 1564.0, votes: 1069 },
+    BoardEntry { prefix: "gemini-4-argon",      display: "Gemini 4 Argon    · Google",      elo: 1553.0, votes: 4440 },
+    BoardEntry { prefix: "claude-fable-5-1",    display: "Claude Fable 5.1  · Anthropic",   elo: 1534.0, votes: 3870 },
+    BoardEntry { prefix: "claude-fable-5",      display: "Claude Fable 5    · Anthropic",   elo: 1551.0, votes: 11686 },
+    BoardEntry { prefix: "claude-opus-4-7",     display: "Claude Opus 4.7   · Anthropic",   elo: 1546.0, votes: 18359 },
+    BoardEntry { prefix: "claude-opus-4-6",     display: "Claude Opus 4.6   · Anthropic",   elo: 1547.0, votes: 24575 },
+    BoardEntry { prefix: "claude-opus-4-5",     display: "Claude Opus 4.5   · Anthropic",   elo: 1530.0, votes: 7752 },
+    BoardEntry { prefix: "claude-opus-5-5",     display: "Claude Opus 5.5   · Anthropic",   elo: 1546.0, votes: 3257 },
+    BoardEntry { prefix: "claude-opus-5",       display: "Claude Opus 5     · Anthropic",   elo: 1532.0, votes: 18838 },
+    BoardEntry { prefix: "claude-sonnet-5-5",   display: "Claude Sonnet 5.5 · Anthropic",   elo: 1517.0, votes: 3109 },
+    BoardEntry { prefix: "claude-sonnet-5",     display: "Claude Sonnet 5   · Anthropic",   elo: 1520.0, votes: 14082 },
+    BoardEntry { prefix: "claude-sonnet-4-6",   display: "Claude Sonnet 4.6 · Anthropic",   elo: 1528.0, votes: 19474 },
+    BoardEntry { prefix: "claude-haiku-5-5",    display: "Claude Haiku 5.5  · Anthropic",   elo: 1455.0, votes: 3003 },
+    BoardEntry { prefix: "claude-haiku-4-5",    display: "Claude Haiku 4.5  · Anthropic",   elo: 1453.0, votes: 39588 },
+    BoardEntry { prefix: "gpt-6-astra",         display: "GPT-6 Astra       · OpenAI",      elo: 1548.0, votes: 4096 },
+    BoardEntry { prefix: "gpt-6-1-sol",         display: "GPT-6.1 Sol       · OpenAI",      elo: 1541.0, votes: 2668 },
+    BoardEntry { prefix: "gpt-6-sol",           display: "GPT-6 Sol         · OpenAI",      elo: 1519.0, votes: 4530 },
+    BoardEntry { prefix: "gpt-6-luna",          display: "GPT-6 Luna        · OpenAI",      elo: 1501.0, votes: 24306 },
+    BoardEntry { prefix: "gpt-5-6-sol",         display: "GPT-5.6 Sol       · OpenAI",      elo: 1533.0, votes: 11621 },
+    BoardEntry { prefix: "gpt-5-5",             display: "GPT-5.5           · OpenAI",      elo: 1510.0, votes: 19751 },
+    BoardEntry { prefix: "gpt-5-4",             display: "GPT-5.4           · OpenAI",      elo: 1521.0, votes: 17419 },
+    BoardEntry { prefix: "gpt-5-2",             display: "GPT-5.2           · OpenAI",      elo: 1442.0, votes: 12151 },
+    BoardEntry { prefix: "muse-wonder",         display: "Muse Wonder       · Meta",        elo: 1546.0, votes: 2780 },
+    BoardEntry { prefix: "muse-spark-1-3",      display: "Muse Spark 1.3    · Meta",        elo: 1532.0, votes: 6575 },
+    BoardEntry { prefix: "kimi-k3",             display: "Kimi K3           · Moonshot",    elo: 1537.0, votes: 10072 },
+    BoardEntry { prefix: "kimi-k2-6",           display: "Kimi K2.6         · Moonshot",    elo: 1516.0, votes: 10982 },
+    BoardEntry { prefix: "glm-5-3",             display: "GLM-5.3           · Z.ai",        elo: 1522.0, votes: 7164 },
+    BoardEntry { prefix: "glm-5-3-flash",       display: "GLM-5.3-Flash     · Z.ai",        elo: 1527.0, votes: 12519 },
+    BoardEntry { prefix: "glm-5-2",             display: "GLM-5.2           · Z.ai",        elo: 1515.0, votes: 14375 },
+    BoardEntry { prefix: "glm-4-6",             display: "GLM 4.6           · Z.ai",        elo: 1449.0, votes: 7577 },
+    BoardEntry { prefix: "deepseek-v4-1-flash", display: "DeepSeek V4.1 Flash · DeepSeek",  elo: 1525.0, votes: 3719 },
+    BoardEntry { prefix: "deepseek-v4-pro",     display: "DeepSeek V4 Pro   · DeepSeek",    elo: 1503.0, votes: 2756 },
+    BoardEntry { prefix: "qwen3-8-max",         display: "Qwen3.8-Max       · Alibaba",     elo: 1524.0, votes: 9596 },
+    BoardEntry { prefix: "qwen3-8-27b",         display: "Qwen3.8-27B       · Alibaba",     elo: 1478.0, votes: 8592 },
+    BoardEntry { prefix: "grok-4-6",            display: "Grok 4.6          · xAI",         elo: 1508.0, votes: 8571 },
+    BoardEntry { prefix: "mimo-v2-6-pro",       display: "MiMo-V2.6-Pro     · Xiaomi",      elo: 1538.0, votes: 1095 },
+    BoardEntry { prefix: "mimo-v2-6-flash",     display: "MiMo-V2.6-Flash   · Xiaomi",      elo: 1511.0, votes: 5033 },
+    BoardEntry { prefix: "gemini-3-8-flash",    display: "Gemini 3.8 Flash  · Google",      elo: 1530.0, votes: 15174 },
+    BoardEntry { prefix: "gemini-3-7-flash",    display: "Gemini 3.7 Flash  · Google",      elo: 1520.0, votes: 8973 },
+    BoardEntry { prefix: "gemini-3-6-flash",    display: "Gemini 3.6 Flash  · Google",      elo: 1518.0, votes: 10179 },
+    BoardEntry { prefix: "gemini-2-5-pro",      display: "Gemini 2.5 Pro    · Google",      elo: 1452.0, votes: 26810 },
+];
+
+/// a representative agentic token blend (fractions of billable tokens)
+const BLEND_IN: f64 = 0.2;
+const BLEND_OUT: f64 = 0.1;
+const BLEND_CACHE: f64 = 0.7;
+const ELO_BASELINE: f64 = 1400.0;
+
+fn agent_blend(p: crate::price::Pricing) -> f64 {
+    BLEND_IN * p.input + BLEND_OUT * p.output + BLEND_CACHE * p.cache_read
+}
+
+#[derive(Clone, Copy, PartialEq)]
+pub enum Sort {
+    Elo,
+    Value,
+    Blend,
+}
+
+pub fn parse_sort(s: &str) -> Result<Sort, String> {
+    match s {
+        "elo" | "score" => Ok(Sort::Elo),
+        "value" => Ok(Sort::Value),
+        "price" | "cost" | "blend" => Ok(Sort::Blend),
+        _ => Err("--sort is elo | value | price".into()),
+    }
+}
+
+pub fn print_board(db: &PriceDB, sort: Sort, top: usize, json: bool) {
+    let mut rows: Vec<(&BoardEntry, Option<f64>, Option<f64>)> = BOARD
+        .iter()
+        .map(|b| {
+            let blend = db.lookup(b.prefix).map(agent_blend);
+            let value = blend.map(|blend| (b.elo - ELO_BASELINE) / blend);
+            (b, blend, value)
+        })
+        .collect();
+
+    match sort {
+        Sort::Elo => rows.sort_by(|a, b| {
+            b.0.elo
+                .partial_cmp(&a.0.elo)
+                .unwrap_or(std::cmp::Ordering::Equal)
+        }),
+        Sort::Value => rows.sort_by(|a, b| {
+            b.2.unwrap_or(f64::NEG_INFINITY)
+                .partial_cmp(&a.2.unwrap_or(f64::NEG_INFINITY))
+                .unwrap_or(std::cmp::Ordering::Equal)
+        }),
+        Sort::Blend => rows.sort_by(|a, b| {
+            a.1.unwrap_or(f64::INFINITY)
+                .partial_cmp(&b.1.unwrap_or(f64::INFINITY))
+                .unwrap_or(std::cmp::Ordering::Equal)
+        }),
+    }
+
+    if json {
+        use serde_json::json;
+        let arr: Vec<_> = rows
+            .iter()
+            .take(top)
+            .map(|(b, blend, value)| {
+                json!({
+                    "model": b.display.trim(),
+                    "prefix": b.prefix,
+                    "arena_elo": b.elo,
+                    "votes": b.votes,
+                    "agent_blend_usd_per_1m": blend.map(|x| (x * 100.0).round() / 100.0),
+                    "value_elo_per_dollar": value.map(|x| (x * 10.0).round() / 10.0),
+                })
+            })
+            .collect();
+        println!(
+            "{}",
+            json!({
+                "source": "LMArena Coding snapshot Nov 2026",
+                "blend": {"input": BLEND_IN, "output": BLEND_OUT, "cache_read": BLEND_CACHE},
+                "rows": arr,
+            })
+        );
+        return;
+    }
+
+    println!();
+    println!("  {BOLD}costcrew leaderboard{RESET} {DIM}· LMArena Coding snapshot Nov 2026 · ~2.0M blind votes{RESET}");
+    println!();
+    println!(
+        "  {:>3} {:<30} {:>5} {:>7} {:>8} {:>8} {:>9} {:>10}",
+        "#", "model", "elo", "votes", "in $", "out $", "agent$", "elo/$"
+    );
+    println!(
+        "  {}",
+        "-".repeat(3 + 1 + 30 + 1 + 5 + 1 + 7 + 1 + 8 + 1 + 8 + 1 + 9 + 1 + 10)
+    );
+
+    for (i, (b, blend, value)) in rows.iter().take(top).enumerate() {
+        let blend = *blend;
+        let value = *value;
+        let (bi, bo) = match blend {
+            Some(_) => {
+                let p = db.lookup(b.prefix).expect("blend implies price");
+                (p.input, p.output)
+            }
+            None => (f64::NAN, f64::NAN),
+        };
+        let price_str = |v: f64| {
+            if blend.is_some() {
+                format!("{:>7.2}", v)
+            } else {
+                "      ?".to_string()
+            }
+        };
+        let blend_str = match blend {
+            Some(blend) => format!("{:.2}", blend),
+            None => "?".into(),
+        };
+        let value_str = match value {
+            Some(v) if v.is_finite() => format!("{:.1}", v),
+            _ => "-".into(),
+        };
+        let color = match value {
+            Some(v) if blend.is_some_and(|blend| blend > 0.0) && v >= 25.0 => GREEN,
+            Some(v) if blend.is_some_and(|blend| blend > 0.0) && v >= 8.0 => YELLOW,
+            _ if value.is_some() => RED,
+            _ => DIM,
+        };
+        println!(
+            "  {:>3} {:<30} {:>5.0} {:>7} {} {} {:>9} {color}{:>10}{RESET}",
+            i + 1,
+            b.display,
+            b.elo,
+            format_votes(b.votes),
+            price_str(bi),
+            price_str(bo),
+            blend_str,
+            value_str,
+            color = color,
+        );
+    }
+
+    if rows.iter().all(|(_, _, _)| true) && rows.iter().any(|(_, blend, _)| blend.is_none()) {
+        println!();
+        println!("  {DIM}? = model not in your price sources yet. `costcrew fetch-prices` may fix it.{RESET}");
+    }
+    println!();
+    println!(
+        "  {DIM}agent$ = typical agentic blend: 20% in + 10% out + 70% cache-read (per 1M).{RESET}"
+    );
+    println!("  {DIM}elo/$  = (elo − 1400) ÷ agent$ — value points per dollar{RESET}");
+    println!("  {DIM}snapshot: arena.ai / lmarena.ai — bump `src/board.rs` with a PR{RESET}");
+    println!();
+}
+
+fn format_votes(v: u64) -> String {
+    if v >= 1000 {
+        format!("{:.1}k", v as f64 / 1000.0)
+    } else {
+        format!("{v}")
+    }
+}

package/src/catalog.rs

@@ -0,0 +1,136 @@
+//! `costcrew catalog` — what every coding agent can run on, and how it bills.
+
+use crate::report::{BOLD, CYAN, DIM, RESET};
+
+pub struct Agent {
+    pub name: &'static str,
+    /// how it bills
+    pub billing: &'static str,
+    /// can it run on arbitrary API keys?
+    pub byok: &'static str,
+    /// whether costcrew can read its logs
+    pub scanned: &'static str,
+    pub models: &'static str,
+    pub url: &'static str,
+}
+
+const CATALOG: &[Agent] = &[
+    Agent {
+        name: "Claude Code",
+        billing: "Pro/Max subscription (weekly caps) OR pay-per-token API",
+        byok: "yes (Anthropic key)",
+        scanned: "yes (JSONL transcripts)",
+        models: "claude-opus / sonnet / haiku (all tiers)",
+        url: "docs.anthropic.com/claude-code",
+    },
+    Agent {
+        name: "OpenCode",
+        billing: "free, open source; you pay the model",
+        byok: "yes — Anthropic, OpenAI, Google, OpenRouter, GLM, local",
+        scanned: "yes (sqlite + JSON)",
+        models: "any provider; public models include big-pickle (free tier)",
+        url: "opencode.ai",
+    },
+    Agent {
+        name: "Codex CLI",
+        billing: "bundled with ChatGPT Plus/Pro; API per-token otherwise",
+        byok: "OpenAI key",
+        scanned: "best-effort (JSONL)",
+        models: "gpt-5 codex line (fast/slow lanes)",
+        url: "github.com/openai/codex",
+    },
+    Agent {
+        name: "Gemini CLI",
+        billing: "free tier ~1,000 req/day with Google login; Vertex/Studio per-token",
+        byok: "yes (GCP key)",
+        scanned: "not yet",
+        models: "gemini 3 / 2 nano",
+        url: "github.com/google-gemini/gemini-cli",
+    },
+    Agent {
+        name: "GitHub Copilot CLI",
+        billing: "Copilot Pro/Pro+ subscription; some models bill per premium-request",
+        byok: "no",
+        scanned: "not yet",
+        models: "gpt + claude + gemini, managed by GitHub policy",
+        url: "github.com/features/copilot",
+    },
+    Agent {
+        name: "Kilo Code",
+        billing: "extension, free; pay via OpenRouter or your own API keys",
+        byok: "yes (OpenRouter recommended)",
+        scanned: "yes-best-effort (task JSON)",
+        models: "anything on OpenRouter incl. free deepseek/qwen lanes",
+        url: "kilocode.ai",
+    },
+    Agent {
+        name: "Cline",
+        billing: "extension, free; bring API keys (incl. Anthropic/OpenRouter)",
+        byok: "yes — per-task cost shown in-app",
+        scanned: "yes-best-effort (task JSON)",
+        models: "any; plus auto-mode model picking",
+        url: "cline.bot",
+    },
+    Agent {
+        name: "Roo Code",
+        billing: "extension, free; BYOK",
+        byok: "yes; models scoped per mode (ask/code/architect)",
+        scanned: "yes-best-effort (task JSON)",
+        models: "anything through the major providers",
+        url: "roocode.com",
+    },
+    Agent {
+        name: "Aider",
+        billing: "open source CLI; pay per API token; total printed per commit",
+        byok: "yes — literally any openai-compatible endpoint incl. local Ollama",
+        scanned: "yes (Cost lines in .aider.chat.history.md)",
+        models: "any; pairs well with deepseek-chat",
+        url: "aider.chat",
+    },
+    Agent {
+        name: "Cursor",
+        billing: "Pro subscription ($20) + usage-based add-ons for frontier models",
+        byok: "limited",
+        scanned: "not yet",
+        models: "bundled: claude, gpt, gemini, cursor's own mini models",
+        url: "cursor.com",
+    },
+    Agent {
+        name: "Windsurf",
+        billing: "sub plans with monthly credit pool; overage billed",
+        byok: "yes on some tiers",
+        scanned: "not yet",
+        models: "bundled claude/gpt + their ide models",
+        url: "windsurf.com",
+    },
+    Agent {
+        name: "self-hosted (vLLM/ollama/llama.cpp)",
+        billing: "GPU rental from $1–3/hr (cloud) to free (local); electricity",
+        byok: "n/a — it IS the server",
+        scanned: "not yet (roadmap: opencode sessions cover it)",
+        models: "llama, qwen, deepseek, glm, mistral — open weights",
+        url: "docs.vllm.ai",
+    },
+];
+
+pub fn print_catalog() {
+    println!();
+    println!(
+        "  {BOLD}costcrew catalog{RESET} {DIM}· who runs what · list-price snapshot mid-2026{RESET}"
+    );
+    println!();
+
+    for a in CATALOG {
+        println!("  {CYAN}{BOLD}{:<33}{RESET}", a.name);
+        println!("  {DIM}billing :{RESET} {}", a.billing);
+        println!("  {DIM}models  :{RESET} {}", a.models);
+        println!("  {DIM}byok    :{RESET} {}", a.byok);
+        println!("  {DIM}scanned :{RESET} {}", a.scanned);
+        println!("  {DIM}link    :{RESET} {}", a.url);
+        println!();
+    }
+    println!(
+        "  {DIM}got a lane we're missing? open an issue: github.com/Arch087146/costcrew{RESET}"
+    );
+    println!();
+}

package/src/demo.rs

@@ -0,0 +1,79 @@
+//! Synthetic data so users can see the report before they've used any agent.
+
+use crate::scan::{aggregate, Row, UsageEvent};
+
+/// Roughly realistic fake week of usage.
+pub fn demo_events() -> Vec<UsageEvent> {
+    fn ev(provider: &str, model: &str, i: u64, o: u64, cr: u64, cw: u64) -> UsageEvent {
+        UsageEvent {
+            provider: provider.into(),
+            model: model.into(),
+            input_tokens: i,
+            output_tokens: o,
+            cache_read: cr,
+            cache_write: cw,
+            duration_ms: 0,
+            direct_cost: None,
+            source: "demo".into(),
+        }
+    }
+
+    vec![
+        // a heavy week of Claude Code refactoring
+        ev(
+            "claude",
+            "claude-opus-4-5-20260115",
+            40_000,
+            9_000,
+            2_100_000,
+            310_000,
+        ),
+        ev(
+            "claude",
+            "claude-opus-4-5-20260115",
+            31_000,
+            7_400,
+            1_850_000,
+            280_000,
+        ),
+        ev(
+            "claude",
+            "claude-sonnet-4-5",
+            22_000,
+            5_100,
+            980_000,
+            140_000,
+        ),
+        ev(
+            "claude",
+            "claude-sonnet-4-5",
+            18_500,
+            4_300,
+            870_000,
+            120_000,
+        ),
+        ev(
+            "claude",
+            "claude-sonnet-4-5",
+            15_000,
+            3_800,
+            760_000,
+            98_000,
+        ),
+        // OpenCode doing feature work on GLM
+        ev("opencode", "glm-5", 48_000, 12_000, 240_000, 60_000),
+        ev("opencode", "glm-5", 39_000, 9_800, 190_000, 44_000),
+        ev("opencode", "glm-5", 27_000, 6_900, 130_000, 31_000),
+        // Codex quick sessions
+        ev("codex", "gpt-5.2-codex", 12_000, 2_400, 410_000, 80_000),
+        ev("codex", "gpt-5.2-codex", 8_000, 1_600, 260_000, 51_000),
+        // deepseek via an API key (Kilo Code / OpenRouter lane)
+        ev("kilo", "deepseek-chat", 33_000, 7_200, 640_000, 96_000),
+        // one model we don't have a price for
+        ev("opencode", "mystery-coder-xl", 30_000, 8_000, 0, 10_000),
+    ]
+}
+
+pub fn demo_rows(db: &super::price::PriceDB) -> Vec<Row> {
+    aggregate(&demo_events(), db)
+}