@archeagle087/costcrew 0.4.1 → 0.4.2

package/src/board.rs

@@ -1,227 +0,0 @@
-//! `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

@@ -1,136 +0,0 @@
-//! `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

@@ -1,79 +0,0 @@
-//! 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)
-}

package/src/fetch.rs

@@ -1,155 +0,0 @@
-//! Live pricing + spend from OpenRouter.
-//!
-//! Two uses:
-//!   1. `--fetch-prices` pulls every OpenRouter model's price (public endpoint,
-//!      no key) and caches it locally — covers "every model, automatically".
-//!   2. `costcrew openrouter` reads your OPENROUTER_API_KEY and reports what
-//!      you actually spent, per model, from the activity endpoint.
-
-use crate::price::{PriceDB, Pricing};
-use serde_json::Value;
-use std::path::PathBuf;
-use std::time::{Duration, SystemTime};
-
-const MODELS_URL: &str = "https://openrouter.ai/api/v1/models";
-const ACTIVITY_URL: &str = "https://openrouter.ai/api/v1/activity?limit=200";
-const CACHE_VERSION: u64 = 1;
-
-pub fn cache_dir() -> PathBuf {
-    if let Some(lad) = std::env::var_os("LOCALAPPDATA") {
-        return PathBuf::from(lad).join("costcrew");
-    }
-    std::env::var_os("HOME")
-        .map(PathBuf::from)
-        .unwrap_or_else(|| PathBuf::from("."))
-        .join(".cache/costcrew")
-}
-
-fn num(s: &Value) -> f64 {
-    match s {
-        Value::Number(n) => n.as_f64().unwrap_or(0.0),
-        Value::String(s) => s.trim().parse().unwrap_or(0.0),
-        _ => 0.0,
-    }
-}
-
-/// Public models endpoint -> per-1M USD prices, cached on disk.
-pub fn force_refresh() -> Result<usize, String> {
-    let resp = ureq::get(MODELS_URL)
-        .timeout(Duration::from_secs(30))
-        .call()
-        .map_err(|e| format!("fetch failed: {e}"))?;
-    let text = resp.into_string().map_err(|e| e.to_string())?;
-    let v: Value = serde_json::from_str(&text).map_err(|e| e.to_string())?;
-
-    let mut models: Vec<(String, [f64; 4])> = Vec::new();
-    if let Some(list) = v.get("data").and_then(Value::as_array) {
-        for m in list {
-            let id = match m.get("id").and_then(Value::as_str) {
-                Some(id) => id.to_string(),
-                None => continue,
-            };
-            // pricing is per-token strings; scale to per-1M
-            let p = m.get("pricing").cloned().unwrap_or(Value::Null);
-            let scale = 1_000_000.0;
-            let price = [
-                num(&p.get("prompt").cloned().unwrap_or(Value::Null)) * scale,
-                num(&p.get("completion").cloned().unwrap_or(Value::Null)) * scale,
-                num(&p.get("input_cache_read").cloned().unwrap_or(Value::Null)) * scale,
-                num(&p.get("input_cache_write").cloned().unwrap_or(Value::Null)) * scale,
-            ];
-            models.push((id, price));
-        }
-    }
-    if models.is_empty() {
-        return Err("openrouter returned no models".into());
-    }
-    let doc = serde_json::json!({
-        "version": CACHE_VERSION,
-        "fetched_at_ms": now_ms(),
-        "models": models.iter().map(|(id, p)| serde_json::json!({
-            "id": id, "prompt": p[0], "completion": p[1], "cache_read": p[2], "cache_write": p[3],
-        })).collect::<Vec<_>>(),
-    });
-    let dir = cache_dir();
-    std::fs::create_dir_all(&dir).map_err(|e| e.to_string())?;
-    std::fs::write(dir.join("openrouter-prices.json"), doc.to_string())
-        .map_err(|e| e.to_string())?;
-    Ok(models.len())
-}
-
-pub fn cached_into_db(db: &mut PriceDB) -> usize {
-    let path = cache_dir().join("openrouter-prices.json");
-    let Ok(text) = std::fs::read_to_string(&path) else {
-        return 0;
-    };
-    let Ok(v) = serde_json::from_str::<Value>(&text) else {
-        return 0;
-    };
-    if v.get("version").and_then(Value::as_u64) != Some(CACHE_VERSION) {
-        return 0;
-    }
-    let mut n = 0usize;
-    if let Some(list) = v.get("models").and_then(Value::as_array) {
-        for m in list {
-            let id = match m.get("id").and_then(Value::as_str) {
-                Some(s) => s.to_string(),
-                None => continue,
-            };
-            db.push(
-                &id,
-                "cache",
-                Pricing {
-                    input: num(&m["prompt"]),
-                    output: num(&m["completion"]),
-                    cache_read: num(&m["cache_read"]),
-                    cache_write: num(&m["cache_write"]),
-                    per_hour: 0.0,
-                },
-            );
-            n += 1;
-        }
-    }
-    db.cache_count = n;
-    n
-}
-
-/// Actual spend per model for an OpenRouter API key.
-pub fn activity(key: &str) -> Result<Vec<(String, u64, f64)>, String> {
-    let resp = ureq::get(ACTIVITY_URL)
-        .timeout(Duration::from_secs(30))
-        .set("Authorization", &format!("Bearer {key}"))
-        .call()
-        .map_err(|e| format!("openrouter request failed: {e}"))?;
-    let text = resp.into_string().map_err(|e| e.to_string())?;
-    let v: Value = serde_json::from_str(&text).map_err(|e| e.to_string())?;
-    if let Some(msg) = v.get("error") {
-        return Err(format!("openrouter error: {msg}"));
-    }
-
-    let mut by_model: Vec<(String, u64, f64)> = Vec::new();
-    if let Some(list) = v.get("data").and_then(Value::as_array) {
-        for ev in list {
-            let model = match ev.get("model").and_then(Value::as_str) {
-                Some(m) => m.to_string(),
-                None => continue,
-            };
-            let cost = num(ev.get("cost").unwrap_or(&Value::Null));
-            if let Some(row) = by_model.iter_mut().find(|(m, _, _)| *m == model) {
-                row.1 += 1;
-                row.2 += cost;
-            } else {
-                by_model.push((model, 1, cost));
-            }
-        }
-    }
-    by_model.sort_by(|a, b| b.2.partial_cmp(&a.2).unwrap_or(std::cmp::Ordering::Equal));
-    Ok(by_model)
-}
-
-fn now_ms() -> u64 {
-    SystemTime::now()
-        .duration_since(SystemTime::UNIX_EPOCH)
-        .map(|d| d.as_millis() as u64)
-        .unwrap_or(0)
-}