@archeagle087/costcrew 0.0.0-stage → 0.4.0

package/src/price.rs

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

package/src/prices.rs

@@ -0,0 +1,182 @@
+//! `costcrew prices` — browse the bundled price database.
+//!
+//! The database ships with the binary: a curated vendor table plus the full
+//! embedded OpenRouter catalog (data/prices.json), optionally enriched by the
+//! on-disk cache (`fetch-prices`) and custom overrides (`--prices`). No
+//! network, no log scanning — it's just a database you can read.
+
+use crate::price::PriceDB;
+use crate::report::{BOLD, CYAN, DIM, GREEN, RESET, YELLOW};
+
+pub fn print_prices(db: &PriceDB, query: Option<&str>, sort: &str, top: usize, json: bool) {
+    // filter + dedupe: the same model can appear in curated + embedded +
+    // cache + custom; the LATEST entry is authoritative (matches lookup order)
+    let mut latest: std::collections::HashMap<String, &crate::price::PriceEntry> =
+        std::collections::HashMap::new();
+    for e in db.entries() {
+        if let Some(q) = query {
+            if !e.prefix.to_lowercase().contains(&q.to_lowercase()) {
+                continue;
+            }
+        }
+        latest.insert(e.prefix.clone(), e);
+    }
+    let mut rows: Vec<&crate::price::PriceEntry> = latest.into_values().collect();
+
+    match sort {
+        "price" | "cost" => rows.sort_by(|a, b| {
+            let ka = a.price.input + a.price.output;
+            let kb = b.price.input + b.price.output;
+            kb.partial_cmp(&ka).unwrap_or(std::cmp::Ordering::Equal) // priciest first
+        }),
+        "cheap" => rows.sort_by(|a, b| {
+            let ka = a.price.input + a.price.output;
+            let kb = b.price.input + b.price.output;
+            ka.partial_cmp(&kb).unwrap_or(std::cmp::Ordering::Equal) // cheapest first
+        }),
+        _ => rows.sort_by(|a, b| a.prefix.cmp(&b.prefix)), // name
+    }
+
+    if json {
+        use serde_json::json;
+        let arr: Vec<_> = rows
+            .iter()
+            .take(top.max(1))
+            .map(|e| {
+                json!({
+                    "model": e.prefix,
+                    "input_per_1m": e.price.input,
+                    "output_per_1m": e.price.output,
+                    "cache_read_per_1m": e.price.cache_read,
+                    "cache_write_per_1m": e.price.cache_write,
+                    "per_hour": if e.price.per_hour > 0.0 { serde_json::Value::from(e.price.per_hour) } else { serde_json::Value::Null },
+                    "source": e.src,
+                })
+            })
+            .collect();
+        println!(
+            "{}",
+            json!({
+                "total_models": db.entries().len(),
+                "matches": rows.len(),
+                "rows": arr,
+            })
+        );
+        return;
+    }
+
+    println!();
+    println!(
+        "  {BOLD}costcrew price database{RESET} {DIM}· bundled, {} models{RESET}",
+        db.entries().len()
+    );
+    println!(
+        "  {DIM}{} curated table · {} embedded snapshot · {} live cache{} · {} custom{RESET}",
+        db.entries().iter().filter(|e| e.src == "curated").count(),
+        db.embedded_count,
+        db.cache_count,
+        if db.embedded_fetched_at_ms > 0 {
+            format!(" (snapshot {})", date_of(db.embedded_fetched_at_ms))
+        } else {
+            String::new()
+        },
+        db.custom_count,
+    );
+    println!("  {DIM}refresh anytime: {RESET}{CYAN}costcrew fetch-prices{RESET}");
+    println!();
+    if let Some(q) = query {
+        println!("  {BOLD}{} matches for \"{q}\"{RESET}{DIM}  (--sort name|price|cheap, --top N, --json){RESET}", rows.len());
+        println!();
+    }
+    println!(
+        "  {:<44} {:>9} {:>9} {:>10}  {:<8}",
+        "model", "in $/1M", "out $/1M", "cache $/1M", "source"
+    );
+    println!("  {}", "-".repeat(44 + 3 + 9 + 3 + 9 + 3 + 10 + 2 + 8));
+
+    for e in rows.iter().take(top) {
+        let (i, o, c) = (e.price.input, e.price.output, e.price.cache_read);
+        let fmt = |v: f64| {
+            if v > 0.0 {
+                format!("{v:>9.3}")
+            } else {
+                "        ?".to_string()
+            }
+        };
+        let src_col = match e.src.as_str() {
+            "curated" => GREEN,
+            "embedded" => CYAN,
+            "cache" => YELLOW,
+            _ => DIM,
+        };
+        println!(
+            "  {:<44} {} {} {:>10}  ({src_col}{:<6}{DIM}){RESET}",
+            truncate(&e.prefix, 44),
+            fmt(i),
+            fmt(o),
+            fmt(c),
+            e.src,
+        );
+    }
+
+    if rows.len() > top {
+        println!();
+        println!(
+            "  {DIM}... {} more. narrower filter, or --top {}. e.g.:{RESET}",
+            rows.len() - top,
+            rows.len()
+        );
+        println!(
+            "  {DIM}  costcrew prices {}{RESET}",
+            query.unwrap_or("anthropic")
+        );
+    }
+    if rows.iter().take(top).any(|e| e.price.input == 0.0) {
+        println!();
+        println!(
+            "  {DIM}? = free tier or unpriced. Unknown stays unknown — no invented prices.{RESET}"
+        );
+    }
+    println!();
+}
+
+fn truncate(s: &str, n: usize) -> String {
+    if s.chars().count() <= n {
+        s.to_string()
+    } else {
+        s.chars().take(n - 1).collect::<String>() + "…"
+    }
+}
+
+/// epoch ms → "Nov 10 2026" (civil-from-days, no chrono dependency)
+fn date_of(ms: u64) -> String {
+    if ms == 0 {
+        return "undated".into();
+    }
+    let days = ms / 86_400_000;
+    // Howard Hinnant's civil_from_days
+    let z = days as i64 + 719_468;
+    let era = z.div_euclid(146_097);
+    let doe = z.rem_euclid(146_097);
+    let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
+    let y = yoe + era * 400;
+    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
+    let mp = (5 * doy + 2) / 153;
+    let d = doy - (153 * mp + 2) / 5 + 1;
+    let m = if mp < 10 { mp + 3 } else { mp - 9 };
+    let y = if m <= 2 { y + 1 } else { y };
+    const MON: [&str; 12] = [
+        "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
+    ];
+    format!("{} {} {}", MON[(m - 1) as usize], d, y)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::date_of;
+    #[test]
+    fn epoch_to_civil() {
+        assert_eq!(date_of(1_794_274_886_057), "Nov 10 2026");
+        assert_eq!(date_of(0), "undated");
+    }
+}

package/src/report.rs

@@ -0,0 +1,194 @@
+//! Terminal table + shareable markdown report.
+
+use crate::scan::Row;
+
+pub const RESET: &str = "\x1b[0m";
+pub const DIM: &str = "\x1b[2m";
+pub const BOLD: &str = "\x1b[1m";
+pub const CYAN: &str = "\x1b[36m";
+pub const YELLOW: &str = "\x1b[33m";
+pub const GREEN: &str = "\x1b[32m";
+pub const RED: &str = "\x1b[31m";
+
+pub struct Totals {
+    pub total_cost: f64,
+    pub total_requests: u64,
+    pub unknown_models: usize,
+}
+
+pub fn print_table(rows: &[Row], since_days: u32, totals: &Totals) {
+    let period = if since_days == 1 {
+        "last 24h".to_string()
+    } else {
+        format!("last {since_days}d")
+    };
+
+    println!();
+    println!("  {BOLD}costcrew{RESET} {DIM}· AI agent spend · {period}{RESET}");
+    println!();
+
+    let widths = col_widths(rows);
+    let cost_w = 10;
+
+    // header
+    print!("  ");
+    for (i, h) in [
+        "provider",
+        "model",
+        "reqs",
+        "tokens in",
+        "tokens out",
+        "cache",
+    ]
+    .iter()
+    .enumerate()
+    {
+        print!("{DIM}{:>width$}{RESET}  ", h, width = widths[i]);
+    }
+    println!("{DIM}{:>width$}{RESET}", "cost (usd)", width = cost_w);
+
+    // separator
+    print!("  ");
+    for w in &widths {
+        print!("{DIM}{}{RESET}  ", "-".repeat(*w));
+    }
+    println!("{DIM}{}{RESET}", "-".repeat(cost_w));
+
+    // rows
+    for r in rows {
+        print!("  ");
+        print!("{:>w$}  ", r.provider, w = widths[0]);
+        print!("{:>w$}  ", truncate(&r.model, widths[1]), w = widths[1]);
+        print!("{:>w$}  ", r.requests, w = widths[2]);
+        print!("{:>w$}  ", r.input_tokens, w = widths[3]);
+        print!("{:>w$}  ", r.output_tokens, w = widths[4]);
+        print!("{:>w$}  ", r.cache_tokens, w = widths[5]);
+        if r.known_price {
+            let color = cost_color(r.cost);
+            print!("{}{:>10.4}{}", color, r.cost, RESET);
+        } else {
+            print!("{:>10}", "?");
+        }
+        println!();
+    }
+
+    // totals
+    let t_in: u64 = rows.iter().map(|r| r.input_tokens).sum();
+    let t_out: u64 = rows.iter().map(|r| r.output_tokens).sum();
+    let t_cache: u64 = rows.iter().map(|r| r.cache_tokens).sum();
+    print!("  ");
+    for w in &widths[..2] {
+        print!("{DIM}{}{RESET}  ", "-".repeat(*w));
+    }
+    print!("{BOLD}total{RESET}  ");
+    print!("{:>w$}  ", "", w = widths[2] + 1);
+    print!("{:>w$}  ", t_in, w = widths[3] + 1);
+    print!("{:>w$}  ", t_out, w = widths[4] + 1);
+    print!("{:>w$}  ", t_cache, w = widths[5] + 1);
+    // -0.0 guard: an all-unpriced table shouldn't render as negative money
+    let shown = if totals.total_cost.abs() < 0.000_1 {
+        0.0
+    } else {
+        totals.total_cost
+    };
+    println!("{BOLD}{GREEN}${:>8.2}{RESET}", shown);
+    println!();
+
+    // bar chart of spend share
+    let max = rows.iter().map(|r| r.cost).fold(0.0_f64, f64::max);
+    if max > 0.0 {
+        for r in rows.iter().filter(|r| r.known_price) {
+            let scale = ((r.cost / max) * 24.0).round() as usize;
+            let units = if r.cost > 0.0 { scale.max(1) } else { 0 };
+            let bar: String = std::iter::repeat_n('#', units).collect();
+            let color = cost_color(r.cost);
+            println!(
+                "  {:>26} {color}{bar}{RESET} ${:.2}",
+                truncate(&r.model, 26),
+                r.cost
+            );
+        }
+        println!();
+    }
+
+    if totals.unknown_models > 0 {
+        println!(
+            "  {DIM}{} model(s) not priced yet — saw them, didn't bill them.{RESET}",
+            totals.unknown_models
+        );
+    }
+}
+
+fn cost_color(cost: f64) -> &'static str {
+    if cost < 1.0 {
+        GREEN
+    } else if cost < 10.0 {
+        YELLOW
+    } else {
+        RED
+    }
+}
+
+fn truncate(s: &str, max: usize) -> String {
+    if s.len() <= max {
+        s.to_string()
+    } else {
+        format!("{}…", &s[..max.saturating_sub(1)])
+    }
+}
+
+fn col_widths(rows: &[Row]) -> [usize; 6] {
+    let mut w = [
+        "provider".len(),
+        "model".len(),
+        "reqs".len(),
+        "tokens in".len(),
+        "tokens out".len(),
+        "cache".len(),
+    ];
+    for r in rows {
+        w[0] = w[0].max(r.provider.len());
+        w[1] = w[1].max(r.model.len().min(40));
+        w[2] = w[2].max(r.requests.to_string().len());
+        w[3] = w[3].max(r.input_tokens.to_string().len());
+        w[4] = w[4].max(r.output_tokens.to_string().len());
+        w[5] = w[5].max(r.cache_tokens.to_string().len());
+    }
+    w
+}
+
+pub fn print_markdown(rows: &[Row], since_days: u32, totals: &Totals) {
+    println!("# costcrew report");
+    println!();
+    println!(
+        "AI agent spend, last {since_days} day(s). Generated by [costcrew](https://github.com/Arch087146/costcrew)."
+    );
+    println!();
+    println!("| provider | model | reqs | tokens in | tokens out | cached | cost (USD) |");
+    println!("|---|---|---:|---:|---:|---:|---:|");
+    for r in rows {
+        let cost = if r.known_price {
+            format!("${:.4}", r.cost)
+        } else {
+            "?".to_string()
+        };
+        println!(
+            "| {} | `{}` | {} | {} | {} | {} | {} |",
+            r.provider, r.model, r.requests, r.input_tokens, r.output_tokens, r.cache_tokens, cost
+        );
+    }
+    let t_in: u64 = rows.iter().map(|r| r.input_tokens).sum();
+    let t_out: u64 = rows.iter().map(|r| r.output_tokens).sum();
+    let t_cache: u64 = rows.iter().map(|r| r.cache_tokens).sum();
+    println!(
+        "| **total** | | **{}** | **{}** | **{}** | **{}** | **${:.2}** |",
+        totals.total_requests, t_in, t_out, t_cache, totals.total_cost
+    );
+    if totals.unknown_models > 0 {
+        println!();
+        println!(
+            "> {} model(s) had no price entry and were excluded from totals.",
+            totals.unknown_models
+        );
+    }
+}