@archeagle087/costcrew 0.4.0 → 0.4.2

package/src/main.rs

@@ -1,371 +0,0 @@
-mod advise;
-mod args;
-mod board;
-mod catalog;
-mod demo;
-mod fetch;
-mod price;
-mod prices;
-mod report;
-mod scan;
-mod spend;
-mod ui;
-
-use args::{parse, Args, Cmd};
-use price::PriceDB;
-use report::{print_markdown, print_table, Totals, BOLD, DIM, RESET};
-use scan::{aggregate, collect};
-
-fn main() {
-    let argv: Vec<String> = std::env::args().skip(1).collect();
-
-    // bare `costcrew` = the interactive app (splash + arrow-key menu).
-    // any argument at all = classic flag mode for scripting.
-    if argv.is_empty() {
-        ui::run_app();
-        return;
-    }
-
-    let args = match parse(&argv) {
-        Ok(a) => a,
-        Err(e) => {
-            eprintln!("error: {e}");
-            std::process::exit(2);
-        }
-    };
-    flow(args);
-}
-
-/// one dispatch point, shared by the flag CLI and the interactive menu
-pub fn flow(args: Args) {
-    match args.cmd {
-        Cmd::Overview => overview(&args),
-        Cmd::Prices => {
-            let mut db = PriceDB::builtin();
-            fetch::cached_into_db(&mut db);
-            if let Some(path) = &args.prices {
-                load_custom(&mut db, path);
-            }
-            let sort = args.sort.as_deref().unwrap_or("name").to_string();
-            let query = args.pos.first().cloned();
-            prices::print_prices(&db, query.as_deref(), &sort, args.top, args.json);
-        }
-        Cmd::Spend => spend::print_spend(args.json, args.since_days),
-        Cmd::SpendAdd => spend::add(&args),
-        Cmd::Demo => {
-            let db = PriceDB::builtin();
-            run(demo::demo_rows(&db), args, 7, &db);
-        }
-        Cmd::Catalog => catalog::print_catalog(),
-        Cmd::Leaderboard => {
-            let mut db = PriceDB::builtin();
-            fetch::cached_into_db(&mut db);
-            if let Some(path) = &args.prices {
-                load_custom(&mut db, path);
-            }
-            let sort = match &args.sort {
-                Some(s) => match board::parse_sort(s) {
-                    Ok(s) => s,
-                    Err(e) => {
-                        eprintln!("error: {e}");
-                        std::process::exit(2);
-                    }
-                },
-                None => board::Sort::Elo,
-            };
-            board::print_board(&db, sort, args.top, args.json);
-        }
-        Cmd::OpenRouter => {
-            run_openrouter(&args);
-        }
-        Cmd::Fetch => {
-            println!("fetching OpenRouter price list ...");
-            match fetch::force_refresh() {
-                Ok(n) => println!(
-                    "cached {} models to {}\nnext `costcrew` run prices against them automatically",
-                    n,
-                    fetch::cache_dir().join("openrouter-prices.json").display()
-                ),
-                Err(e) => {
-                    eprintln!("error: {e}");
-                    std::process::exit(1);
-                }
-            }
-        }
-        Cmd::Scan | Cmd::Md | Cmd::Advise => {
-            let mut db = PriceDB::builtin();
-            fetch::cached_into_db(&mut db);
-            if let Some(path) = &args.prices {
-                load_custom(&mut db, path);
-            }
-            let events = collect(args.since_days);
-            if events.is_empty() {
-                if args.cmd == Cmd::Advise {
-                    // advise is understood without a scan — show it on demo data
-                    let db = PriceDB::builtin();
-                    println!("  {DIM}(no local usage found — showing advise on demo data){RESET}");
-                    advise::print_advise(&demo::demo_rows(&db), &db, 7);
-                    return;
-                }
-                eprintln!("no agent usage found on this machine.");
-                eprintln!("scanned ~/.claude, opencode data dirs, ~/.codex, vscode globalStorage, aider history");
-                eprintln!("try `costcrew demo` to see a sample report.");
-                std::process::exit(1);
-            }
-            let days = args.since_days;
-            let rows = aggregate(&events, &db);
-            if args.cmd == Cmd::Advise && !rows.iter().any(|r| r.known_price) {
-                // advise is understood without priced scans — show it on demo data
-                println!(
-                    "{DIM}(no priced usage found locally — showing advise on demo data){RESET}"
-                );
-                advise::print_advise(&demo::demo_rows(&db), &db, 7);
-                return;
-            }
-            run(rows, args, days, &db);
-        }
-    }
-}
-
-fn run(rows: Vec<scan::Row>, args: args::Args, since_days: u32, db: &PriceDB) {
-    let total_cost: f64 = rows.iter().filter(|r| r.known_price).map(|r| r.cost).sum();
-    let total_requests: u64 = rows.iter().map(|r| r.requests).sum();
-    let unknown_models = rows.iter().filter(|r| !r.known_price).count();
-    let totals = Totals {
-        total_cost,
-        total_requests,
-        unknown_models,
-    };
-
-    if args.json {
-        print_json(&rows, &totals);
-        return;
-    }
-
-    match args.cmd {
-        Cmd::Md => print_markdown(&rows, since_days, &totals),
-        Cmd::Advise => advise::print_advise(&rows, db, since_days),
-        _ => print_table(&rows, since_days, &totals),
-    }
-}
-
-/// Bare `costcrew` — the two things the tool is about:
-/// the bundled price database, and YOUR spend on AI.
-fn overview(args: &args::Args) {
-    use report::{CYAN, GREEN, YELLOW};
-    let mut db = PriceDB::builtin();
-    fetch::cached_into_db(&mut db);
-    if let Some(path) = &args.prices {
-        load_custom(&mut db, path);
-    }
-    let total = db.entries().len();
-
-    println!();
-    println!("  {BOLD}costcrew{RESET} {DIM}· the AI coding price database + your spend{RESET}");
-    println!();
-
-    println!("  {BOLD}THE DATABASE{RESET} {GREEN}{total} models priced{RESET} {DIM}(bundled — works offline){RESET}");
-    println!("  {DIM}per-model: input / output / cache rates per 1M tokens{RESET}");
-    println!();
-    println!(
-        "    {CYAN}costcrew prices{RESET}            browse everything {DIM}({} curated + {} embedded){RESET}",
-        db.entries().iter().filter(|e| e.src == "curated").count(),
-        db.embedded_count
-    );
-    println!("    {CYAN}costcrew prices claude{RESET}     filter by name {DIM}(--sort price|cheap|name){RESET}");
-    println!("    {CYAN}costcrew leaderboard{RESET}       arena Elo, priced: elo-per-dollar value ranking");
-    println!("    {CYAN}costcrew catalog{RESET}           which agent ships with which models");
-    println!(
-        "    {CYAN}costcrew fetch-prices{RESET}      refresh from OpenRouter live (~{} models)",
-        db.embedded_count.max(465)
-    );
-
-    // ---- your spend ----
-    let entries = spend_load_entries();
-    let today = today_str();
-    let this_month = entries
-        .iter()
-        .filter(|e| e.date.chars().take(7).collect::<String>() == today[..7])
-        .map(|e| e.amount)
-        .sum::<f64>();
-    println!();
-    println!("  {BOLD}YOUR SPEND ON AI{RESET}");
-    if entries.is_empty() {
-        println!(
-            "  {YELLOW}nothing recorded yet{RESET} {DIM}— log what you actually pay (subscriptions, credits, GPUs):{RESET}"
-        );
-        println!("    {CYAN}costcrew spend add 20 --service \"Claude Pro\"{RESET}");
-    } else {
-        println!(
-            "  {DIM}this month{RESET} {BOLD}${this_month:>7.2}{RESET} {DIM}· {} entries{RESET}",
-            entries.len()
-        );
-    }
-    println!("    {CYAN}costcrew spend{RESET}            monthly totals + per-service breakdown");
-    println!("    {CYAN}costcrew spend add 25{RESET}     record a payment {DIM}--service --model --note --at{RESET}");
-    println!("    {CYAN}costcrew openrouter{RESET}       actual spend per model from your API key");
-
-    // ---- optional estimates ----
-    println!();
-    println!("  {DIM}optional: {RESET}{DIM}estimate per-token usage from local logs → {RESET}{CYAN}costcrew scan{RESET}");
-    println!(
-        "  {DIM}cheaper-model advice on your own token mix → {RESET}{CYAN}costcrew advise{RESET}"
-    );
-    if args.json {
-        use serde_json::json;
-        println!(
-            "{}",
-            json!({
-                "database_models": total,
-                "curated": db.entries().iter().filter(|e| e.src == "curated").count(),
-                "embedded": db.embedded_count,
-                "cache": db.cache_count,
-                "custom": db.custom_count,
-                "spend_this_month_usd": (this_month * 100.0).round() / 100.0,
-                "spend_entries": entries.len(),
-            })
-        );
-    }
-    println!();
-}
-
-fn spend_load_entries() -> Vec<spend::Entry> {
-    spend::all_entries()
-}
-
-fn today_str() -> String {
-    spend::today()
-}
-
-fn run_openrouter(args: &args::Args) {
-    let key = args
-        .key
-        .clone()
-        .or_else(|| std::env::var("OPENROUTER_API_KEY").ok())
-        .unwrap_or_else(|| {
-            eprintln!("error: set OPENROUTER_API_KEY or pass --key sk-or-v1-...");
-            std::process::exit(2);
-        });
-
-    println!("querying OpenRouter activity (limit 200) ...");
-    match fetch::activity(&key) {
-        Ok(rows) if rows.is_empty() => println!("no recorded spend — nothing on this key yet."),
-        Ok(rows) => {
-            println!();
-            println!("  {BOLD}costcrew{RESET} {DIM}· OPENROUTER actual spend (API key){RESET}");
-            println!();
-            println!("  {:>40}  {:>6}  {:>10}", "model", "reqs", "cost usd");
-            println!("  {}:{}", "-".repeat(40), "-".repeat(19));
-            let total: f64 = rows.iter().map(|(_, _, c)| c).sum();
-            for (model, reqs, cost) in &rows {
-                println!(
-                    "  {:>40}  {:>6}  {:>10.4}",
-                    if model.len() > 40 {
-                        &model[..40]
-                    } else {
-                        model
-                    },
-                    reqs,
-                    cost
-                );
-            }
-            println!("  {:>40}  {:>6}  {:>10.4}", "TOTAL", "", total);
-            println!();
-            println!("  {DIM}this is act bill-truth from the provider — the scan is the estimate.{RESET}");
-        }
-        Err(e) => {
-            eprintln!("error: {e}");
-            std::process::exit(1);
-        }
-    }
-}
-
-fn load_custom(db: &mut PriceDB, path: &str) {
-    use serde_json::Value;
-    let Ok(text) = std::fs::read_to_string(path) else {
-        eprintln!("error: can't read {path}");
-        std::process::exit(2);
-    };
-    let Ok(v) = serde_json::from_str::<Value>(&text) else {
-        eprintln!("error: {path} is not valid JSON");
-        std::process::exit(2);
-    };
-    let n = match v.get("prices") {
-        Some(list) => load_list(db, list),
-        None => {
-            if v.is_array() {
-                load_list(db, &v)
-            } else {
-                0
-            }
-        }
-    };
-    db.custom_count = n;
-    println!(
-        "using {n} custom price entr{} from {path}",
-        if n == 1 { "y" } else { "ies" }
-    );
-}
-
-fn load_list(db: &mut PriceDB, list: &serde_json::Value) -> usize {
-    let mut n = 0;
-    if let Some(items) = list.as_array() {
-        for it in items {
-            let prefix = match it.get("prefix").and_then(serde_json::Value::as_str) {
-                Some(p) => p,
-                None => continue,
-            };
-            let get = |k: &str| {
-                it.get(k)
-                    .and_then(serde_json::Value::as_f64)
-                    .or_else(|| {
-                        it.get(k)
-                            .and_then(serde_json::Value::as_str)
-                            .and_then(|s| s.trim().parse().ok())
-                    })
-                    .unwrap_or(0.0)
-            };
-            db.push(
-                prefix,
-                "custom",
-                price::Pricing {
-                    input: get("input"),
-                    output: get("output"),
-                    cache_read: get("cache_read"),
-                    cache_write: get("cache_write"),
-                    per_hour: get("per_hour"),
-                },
-            );
-            n += 1;
-        }
-    }
-    n
-}
-
-fn print_json(rows: &[scan::Row], t: &Totals) {
-    use serde_json::json;
-    let arr: Vec<_> = rows
-        .iter()
-        .map(|r| {
-            json!({
-                "provider": r.provider,
-                "model": r.model,
-                "requests": r.requests,
-                "input_tokens": r.input_tokens,
-                "output_tokens": r.output_tokens,
-                "cache_tokens": r.cache_tokens,
-                "duration_secs": (r.duration_secs * 10.0).round() / 10.0,
-                "cost_usd": if r.known_price { serde_json::Value::from((r.cost * 10_000.0).round() / 10_000.0) } else { serde_json::Value::Null },
-            })
-        })
-        .collect();
-    println!(
-        "{}",
-        json!({
-            "total_cost_usd": (t.total_cost * 100.0).round() / 100.0,
-            "requests": t.total_requests,
-            "unpriced_models": t.unknown_models,
-            "rows": arr,
-        })
-    );
-}

package/src/price.rs

@@ -1,218 +0,0 @@
-//! Per-model pricing. Approximate list prices, per 1M tokens, USD.
-//! Prefix-matched, longest prefix wins. Match also works on OpenRouter-style
-//! slugs ("anthropic/claude-opus-..." -> "claude-opus-...").
-
-#[derive(Debug, Clone, Copy, Default)]
-pub struct Pricing {
-    /// USD per 1M tokens
-    pub input: f64,
-    pub output: f64,
-    pub cache_read: f64,
-    pub cache_write: f64,
-    /// USD per hour of wall-clock usage (rented GPU / self-hosted inference)
-    pub per_hour: f64,
-}
-
-#[derive(Debug, Clone)]
-pub struct PriceEntry {
-    pub prefix: String,
-    /// where this row came from: "curated" | "embedded" | "cache" | "custom"
-    pub src: String,
-    pub price: Pricing,
-}
-
-pub struct PriceDB {
-    entries: Vec<PriceEntry>,
-    pub embedded_count: usize,
-    pub cache_count: usize,
-    pub custom_count: usize,
-    pub embedded_fetched_at_ms: u64,
-}
-
-/// The bundled price database: a full OpenRouter catalog snapshot, refreshed
-/// monthly by CI and committed to `data/prices.json`. Ships inside the binary —
-/// every install knows every model's price with zero network, zero scanning.
-const EMBEDDED: &str = include_str!("../data/prices.json");
-
-fn prices_from_doc(v: &serde_json::Value, src: &str, db: &mut PriceDB) -> (usize, u64) {
-    let fetched = v
-        .get("fetched_at_ms")
-        .and_then(serde_json::Value::as_u64)
-        .unwrap_or(0);
-    let mut n = 0usize;
-    if let Some(list) = v.get("models").and_then(serde_json::Value::as_array) {
-        for m in list {
-            let id = match m.get("id").and_then(serde_json::Value::as_str) {
-                Some(s) => s,
-                None => continue,
-            };
-            let get = |k: &str| match m.get(k) {
-                Some(serde_json::Value::Number(n)) => n.as_f64().unwrap_or(0.0),
-                Some(serde_json::Value::String(s)) => s.trim().parse().unwrap_or(0.0),
-                _ => 0.0,
-            };
-            db.entries.push(PriceEntry {
-                prefix: id.to_string(),
-                src: src.to_string(),
-                price: Pricing {
-                    input: get("prompt"),
-                    output: get("completion"),
-                    cache_read: get("cache_read"),
-                    cache_write: get("cache_write"),
-                    per_hour: 0.0,
-                },
-            });
-            n += 1;
-        }
-    }
-    (n, fetched)
-}
-
-/// (prefix, input, output, cache_read, cache_write) — curated list-price table.
-/// Sources: vendor price pages as of mid-2026. Treat as approximate.
-const TABLE: &[(&str, f64, f64, f64, f64)] = &[
-    // --- Anthropic ---
-    ("claude-opus-4", 15.0, 75.0, 1.5, 18.75),
-    ("claude-sonnet-4", 3.0, 15.0, 0.3, 3.75),
-    ("claude-haiku-4", 1.0, 5.0, 0.1, 1.25),
-    ("claude-3-7-sonnet", 3.0, 15.0, 0.3, 3.75),
-    ("claude-3-5-sonnet", 3.0, 15.0, 0.3, 3.75),
-    ("claude-3-5-haiku", 0.8, 4.0, 0.08, 1.0),
-    ("claude-3-opus", 15.0, 75.0, 1.5, 18.75),
-    // --- OpenAI ---
-    ("gpt-5", 1.25, 10.0, 0.125, 1.25),
-    ("gpt-4.1", 2.0, 8.0, 0.5, 2.0),
-    ("gpt-4o", 2.5, 10.0, 1.25, 2.5),
-    ("o3", 2.0, 8.0, 0.5, 2.0),
-    ("o4-mini", 1.1, 4.4, 0.28, 1.1),
-    ("codex", 1.25, 10.0, 0.125, 1.25),
-    ("chatgpt", 5.0, 20.0, 0.5, 5.0),
-    // --- Google ---
-    ("gemini-3", 2.0, 12.0, 0.2, 2.0),
-    ("gemini-2", 1.25, 10.0, 0.31, 1.25),
-    ("gemini", 1.25, 10.0, 0.31, 1.25),
-    // --- Zhipu / GLM ---
-    ("glm-5", 1.0, 3.2, 0.11, 1.0),
-    ("glm-4.6", 0.6, 2.2, 0.11, 0.6),
-    ("glm-4", 0.6, 2.2, 0.11, 0.6),
-    // --- DeepSeek ---
-    ("deepseek-chat", 0.27, 1.1, 0.07, 0.27),
-    ("deepseek-reasoner", 0.55, 2.19, 0.14, 0.55),
-    ("deepseek", 0.27, 1.1, 0.07, 0.27),
-    // --- Alibaba ---
-    ("qwen3", 0.4, 1.2, 0.04, 0.4),
-    ("qwen", 0.4, 1.2, 0.04, 0.4),
-    // --- Moonshot ---
-    ("kimi-k2", 0.6, 2.5, 0.07, 0.6),
-    ("kimi", 0.6, 2.5, 0.07, 0.6),
-    // --- xAI ---
-    ("grok-4", 3.0, 15.0, 0.3, 3.0),
-    ("grok-3", 3.0, 15.0, 0.3, 3.0),
-    ("grok", 3.0, 15.0, 0.3, 3.0),
-    // --- Meta ---
-    ("llama-4", 0.5, 0.8, 0.05, 0.5),
-    ("llama-3", 0.9, 0.9, 0.09, 0.9),
-    ("llama", 0.3, 0.3, 0.03, 0.3),
-    // --- Mistral ---
-    ("mistral-large", 2.0, 6.0, 0.2, 2.0),
-    ("mistral-small", 0.1, 0.3, 0.01, 0.1),
-    ("devstral", 0.1, 0.3, 0.01, 0.1),
-    ("codestral", 0.3, 0.9, 0.03, 0.3),
-    ("mistral", 0.15, 0.6, 0.015, 0.15),
-    // --- Others ---
-    ("minimax", 0.3, 1.2, 0.03, 0.3),
-    ("command", 2.5, 10.0, 0.25, 2.5),
-    ("phi", 0.25, 1.0, 0.03, 0.25),
-];
-
-impl PriceDB {
-    /// Curated vendor list + the full embedded catalog — the "everything" DB.
-    pub fn builtin() -> Self {
-        let mut db = Self::curated();
-        let (n, fetched) = prices_from_doc(
-            &serde_json::from_str(EMBEDDED).expect("embedded data/prices.json must parse"),
-            "embedded",
-            &mut db,
-        );
-        db.embedded_count = n;
-        db.embedded_fetched_at_ms = fetched;
-        db
-    }
-
-    /// Just the curated list-price table (used by tests / lean paths).
-    pub fn curated() -> Self {
-        let entries = TABLE
-            .iter()
-            .map(|(prefix, i, o, cr, cw)| PriceEntry {
-                prefix: prefix.to_string(),
-                src: "curated".to_string(),
-                price: Pricing {
-                    input: *i,
-                    output: *o,
-                    cache_read: *cr,
-                    cache_write: *cw,
-                    per_hour: 0.0,
-                },
-            })
-            .collect();
-        PriceDB {
-            entries,
-            embedded_count: 0,
-            cache_count: 0,
-            custom_count: 0,
-            embedded_fetched_at_ms: 0,
-        }
-    }
-
-    /// `src` tags the origin and doubles as precedence: on equal-length
-    /// prefix ties the LATEST entry wins, so the load order
-    /// curated → embedded → cache → custom is also the override order.
-    pub fn push(&mut self, prefix: &str, src: &str, price: Pricing) {
-        self.entries.push(PriceEntry {
-            prefix: prefix.to_string(),
-            src: src.to_string(),
-            price,
-        });
-    }
-
-    pub fn entries(&self) -> &[PriceEntry] {
-        &self.entries
-    }
-
-    fn key_of(model: &str) -> &str {
-        // "anthropic/claude-opus-4" -> "claude-opus-4" so OpenRouter slugs match
-        model.rsplit('/').next().unwrap_or(model)
-    }
-
-    pub fn lookup(&self, model: &str) -> Option<Pricing> {
-        // normalize: OpenRouter uses dots ("claude-fable-5.1"), lmarena/agents
-        // use hyphens — treat both separators as equivalent
-        let norm = |s: &str| {
-            s.to_lowercase()
-                .chars()
-                .map(|c| {
-                    if c == '.' || c == '_' || c == '-' {
-                        '-'
-                    } else {
-                        c
-                    }
-                })
-                .collect::<String>()
-        };
-        let full = norm(model);
-        let seg = Self::key_of(&full).to_string();
-
-        let mut best: Option<(usize, Pricing)> = None; // (prefix_len, price)
-        for e in &self.entries {
-            let p = norm(&e.prefix);
-            let hit = seg.starts_with(&p) || full.starts_with(&p);
-            if hit {
-                let len = p.len();
-                if best.is_none_or(|(l, _)| len >= l) {
-                    best = Some((len, e.price));
-                }
-            }
-        }
-        best.map(|(_, v)| v)
-    }
-}