@archeagle087/costcrew 0.4.1 → 0.4.2

package/scripts/render_screen.py

@@ -1,221 +0,0 @@
-#!/usr/bin/env python3
-"""Render costcrew output to a terminal-style PNG screenshot.
-
-Parses the ANSI sequences costcrew actually emits (so screenshots are always
-genuine), draws them in Consolas on a terminal window with chrome.
-
-Usage:
-  python scripts/render_screen.py assets/demo.png "costcrew demo" -- demo
-  python scripts/render_screen.py assets/scan.png "costcrew scan --since 30d" -- scan --since 30d
-  python scripts/render_screen.py assets/help.png "costcrew --help" -- --help
-
-Commit the PNGs under assets/ — they are pure program output, no hand edits.
-"""
-
-from __future__ import annotations
-
-import re
-import subprocess
-import sys
-from pathlib import Path
-
-from PIL import Image, ImageDraw, ImageFont
-
-ROOT = Path(__file__).resolve().parent.parent
-EXE = ROOT / "target" / "release" / "costcrew.exe"
-
-FG = (230, 237, 243)
-DIM = (139, 148, 158)
-COLORS = {31: (240, 87, 79), 32: (63, 185, 80), 33: (210, 153, 34), 36: (121, 192, 255)}
-BRIGHT = {31: (255, 123, 114), 32: (86, 211, 100), 33: (227, 179, 65)}
-BG = (13, 17, 23)
-BAR_BG = (30, 34, 43)
-DOTS = [(255, 95, 87), (254, 188, 46), (40, 200, 64)]
-
-# xterm 256-color palette for 38;5;N codes (banner gradient etc.)
-_BASE16 = [
-    (0, 0, 0), (205, 49, 49), (63, 185, 80), (210, 153, 34),
-    (121, 192, 255), (188, 63, 188), (97, 214, 214), (230, 237, 243),
-    (139, 148, 158), (255, 123, 114), (86, 211, 100), (227, 179, 65),
-    (163, 217, 255), (255, 128, 255), (154, 237, 237), (255, 255, 255),
-]
-_STEPS = [0, 95, 135, 175, 215, 255]
-
-def _pal256(n: int) -> tuple[int, int, int]:
-    if n < 16:
-        return _BASE16[n]
-    if n < 232:
-        n -= 16
-        r, g, b = (n // 36) % 6, (n // 6) % 6, n % 6
-        return (_STEPS[r], _STEPS[g], _STEPS[b])
-    g = 8 + (n - 232) * 10
-    return (g, g, g)
-
-ANSI_RE = re.compile(r"\x1b\[([0-9;]*)m")
-
-Cell = tuple[tuple[int, int, int], bool, str]  # (color, bold, char)
-
-
-def tokenize_cli(cli_text: str) -> list[Cell]:
-    """Tokenizer for a plain (non-ANSI) command line: whole command in bright FG."""
-    return [(FG, True, ch) for ch in cli_text]
-
-
-def tokenize_ansi(text: str) -> list[Cell]:
-    """Tokenize ANSI text: returns (color, bold, char), newline chars included."""
-    out: list[Cell] = []
-    color = FG
-    bold = False
-    pos = 0
-    for m in ANSI_RE.finditer(text):
-        for ch in text[pos : m.start()]:
-            out.append((color, bold, ch))
-        pos = m.end()
-        codes = [int(x) for x in m.group(1).split(";") if x != ""]
-        i = 0
-        while i < len(codes):
-            c = codes[i]
-            if c == 38 and i + 2 < len(codes) and codes[i + 1] == 5:
-                color = _pal256(codes[i + 2])
-                i += 3
-                continue
-            if c == 0:
-                color, bold = FG, False
-            elif c == 1:
-                bold = True
-            elif c == 2:
-                color = DIM
-            elif c == 22:
-                bold = False
-            elif c in COLORS:
-                base = BRIGHT.get(c) if (bold and c in BRIGHT) else COLORS[c]
-                color = base
-            i += 1
-    out.extend((color, bold, ch) for ch in text[pos:])
-    return out
-
-
-def split_rows(cells: list[Cell]) -> list[list[Cell]]:
-    rows: list[list[Cell]] = []
-    row: list[Cell] = []
-    for cell in cells:
-        if cell[2] == "\n":
-            rows.append(row)
-            row = []
-        else:
-            row.append(cell)
-    if row:
-        rows.append(row)
-    return rows
-
-
-def render(rows: list[list[Cell]], prompt: list[Cell], out_path: Path, title: str):
-    font = ImageFont.truetype(r"C:\Windows\Fonts\consola.ttf", 26)
-    font_bold = ImageFont.truetype(r"C:\Windows\Fonts\consolab.ttf", 26)
-    cell_w = font.getlength("0")
-    cell_h = 34
-    pad = 34
-    bar_h = 58
-    gap = 12
-
-    grid = [prompt] + [[]] + rows  # prompt line, blank line, then output rows
-    max_len = max(len(r) for r in grid)
-    width = int(max_len * cell_w) + pad * 2
-    height = bar_h + gap + cell_h + gap + len(grid[2:]) * cell_h + pad
-
-    img = Image.new("RGB", (width, height), BG)
-    d = ImageDraw.Draw(img)
-
-    # title bar + traffic lights
-    d.rectangle([0, 0, width, bar_h], fill=BAR_BG)
-    for i, tc in enumerate(DOTS):
-        cx = 22 + i * 38
-        cy = bar_h // 2
-        d.ellipse([cx - 11, cy - 11, cx + 11, cy + 11], fill=tc)
-    tf = ImageFont.truetype(r"C:\Windows\Fonts\segoeui.ttf", 22)
-    tw = d.textlength(title, font=tf)
-    d.text(((width - tw) / 2, (bar_h - 24) / 2 + 2), title, font=tf, fill=(200, 205, 215))
-
-    # prompt + output
-    y = bar_h + gap
-    for row in grid:
-        x = 0.0
-        for color, bold, ch in row:
-            f = font_bold if bold else font
-            # block glyphs fill their whole cell (PIL + Consolas leaves seams)
-            if ch == "█":
-                d.rectangle([pad + x, y, pad + x + cell_w - 1, y + cell_h - 1], fill=color)
-            elif ch == "▀":
-                d.rectangle([pad + x, y, pad + x + cell_w - 1, y + cell_h / 2 - 1], fill=color)
-            elif ch == "▄":
-                d.rectangle([pad + x, y + cell_h / 2, pad + x + cell_w - 1, y + cell_h - 1], fill=color)
-            elif ch == "▌":
-                d.rectangle([pad + x, y, pad + x + cell_w / 2 - 1, y + cell_h - 1], fill=color)
-            elif ch == "▐":
-                d.rectangle([pad + x + cell_w / 2, y, pad + x + cell_w - 1, y + cell_h - 1], fill=color)
-            else:
-                d.text((pad + x, y), ch, font=f, fill=color)
-            x += cell_w
-        y += cell_h
-
-    # rounded corners
-    mask = Image.new("L", (width, height), 0)
-    ImageDraw.Draw(mask).rounded_rectangle([0, 0, width - 1, height - 1], radius=16, fill=255)
-    rgba = img.convert("RGBA")
-    rgba.putalpha(mask)
-    rgba.save(out_path)
-    print(f"saved {out_path} ({width}x{height})")
-
-
-def main():
-    if len(sys.argv) < 4 or sys.argv.count("--") != 1:
-        sys.exit(__doc__)
-    out_path = Path(sys.argv[1])
-    out_path.parent.mkdir(exist_ok=True)
-    title = sys.argv[2]
-
-    max_lines = None
-    if "--max-lines" in sys.argv:
-        i = sys.argv.index("--max-lines")
-        max_lines = int(sys.argv[i + 1])
-        del sys.argv[i : i + 2]
-
-    # --from-file: read captured ANSI text instead of running the exe.
-    # Used for the interactive app: drive_ui captures its real output
-    # while the app is alive, then we render that capture.
-    from_file = None
-    if "--from-file" in sys.argv:
-        i = sys.argv.index("--from-file")
-        from_file = Path(sys.argv[i + 1])
-        del sys.argv[i : i + 2]
-
-    run_args = sys.argv[sys.argv.index("--") + 1 :]
-
-    if from_file:
-        body = from_file.read_text(encoding="utf-8") + "\x1b[0m"
-    else:
-        proc = subprocess.run(
-            [str(EXE), *run_args],
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-            errors="replace",
-        )
-        body = (proc.stdout if proc.stdout.strip() else proc.stderr) + "\x1b[0m"
-
-    prompt = [
-        *[(DIM, False, ch) for ch in "PS C:\\sources\\costcrew> "],
-        *tokenize_cli(title),
-        (FG, False, "\n"),
-    ]
-    cells = prompt + tokenize_ansi(body)
-    rows = split_rows(cells)
-    if max_lines:
-        rows = rows[: max_lines + 1]  # prompt row + N body rows
-        rows.append([])  # ellipsis hint line
-        rows.append([(DIM, False, ch) for ch in f"  ... full output: {title}"])
-    render(rows[1:], rows[0], out_path, title)
-
-
-if __name__ == "__main__":
-    main()

package/src/advise.rs

@@ -1,154 +0,0 @@
-//! `costcrew advise` — should you have used a cheaper model?
-//!
-//! Honest heuristic mode: recomputes your ACTUAL token mix under cheaper
-//! alternatives that publish benchmark tiers at/above the model you used.
-//! Quality scores are approximate tiers from public evals — the goal is to
-//! surface waste, not to write your model-selection policy.
-
-use crate::price::PriceDB;
-use crate::report::*;
-use crate::scan::Row;
-
-/// Approximate coding-benchmark tier per model family (5 = frontier).
-/// Rounded, contested, and deliberately conservative: advise only suggests
-/// swapping when the *candidate's tier is >= the model you used*.
-const TIERS: &[(&str, u8)] = &[
-    ("claude-opus", 5),
-    ("gpt-5", 5),
-    ("grok-4", 5),
-    ("gemini-3", 5),
-    ("kimi-k2", 4),
-    ("claude-sonnet", 4),
-    ("glm-5", 4),
-    ("deepseek-reasoner", 4),
-    ("glm-4.6", 3),
-    ("deepseek-chat", 3),
-    ("qwen", 3),
-    ("llama-4", 3),
-    ("mistral-large", 3),
-    ("gemini-2", 3),
-    ("gpt-4.1", 3),
-    ("gpt-4o", 3),
-    ("o3", 4),
-    ("claude-haiku", 3),
-    ("mistral-small", 2),
-    ("devstral", 2),
-    ("codestral", 2),
-    ("mistral", 2),
-    ("minimax", 2),
-    ("command", 2),
-    ("phi", 2),
-];
-
-/// Candidate pool for downgrades — cheapest-first, all tiers.
-const CANDIDATES: &[&str] = &[
-    "claude-haiku-4",
-    "glm-4.6",
-    "deepseek-chat",
-    "qwen3",
-    "mistral-small",
-    "devstral",
-    "kimi-k2",
-    "glm-5",
-    "deepseek-reasoner",
-    "claude-sonnet-4",
-    "gemini-3",
-    "gpt-5",
-    "claude-opus-4",
-];
-
-fn tier_of(model: &str) -> u8 {
-    let m = model.to_lowercase();
-    for (k, t) in TIERS {
-        if m.starts_with(k) {
-            return *t;
-        }
-    }
-    0
-}
-
-/// What this row's token mix would cost on an alternative model.
-fn est_cost(row: &Row, alt: &str, db: &PriceDB) -> Option<f64> {
-    let p = db.lookup(alt)?;
-    Some(
-        (row.input_tokens as f64 / 1e6) * p.input
-            + (row.output_tokens as f64 / 1e6) * p.output
-            + (row.cache_read_tokens as f64 / 1e6) * p.cache_read
-            + (row.cache_write_tokens as f64 / 1e6) * p.cache_write
-            + p.per_hour * (row.duration_secs / 3600.0),
-    )
-}
-
-pub fn print_advise(rows: &[Row], db: &PriceDB, since_days: u32) {
-    println!();
-    println!(
-        "  {BOLD}costcrew advise{RESET} {DIM}· cheaper-model verdicts · last {since_days}d{RESET}"
-    );
-    println!();
-
-    if !rows.iter().any(|r| r.known_price && r.requests > 0) {
-        println!("  {DIM}nothing priced to advise on — run `costcrew` first.{RESET}");
-        return;
-    }
-
-    let mut suggested_ok = 0usize;
-    for r in rows.iter().filter(|r| r.known_price && r.cost > 0.01) {
-        let my_tier = tier_of(&r.model);
-        if my_tier == 0 {
-            // don't pretend to know about unknown-model quality
-            continue;
-        }
-        let mut alts: Vec<(f64, &str, u8)> = CANDIDATES
-            .iter()
-            .filter(|c| tier_of(c) >= my_tier)
-            .filter_map(|c| est_cost(r, c, db).map(|cost| (cost, *c, tier_of(c))))
-            .filter(|(cost, _, _)| *cost < r.cost * 0.9)
-            .collect();
-        alts.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap_or(std::cmp::Ordering::Equal));
-
-        if let Some((alt_cost, alt_name, alt_tier)) = alts.first().copied() {
-            let save = r.cost - alt_cost;
-            let pct = (1.0 - alt_cost / r.cost).max(0.0) * 100.0;
-            let tier_note = if alt_tier == my_tier {
-                "same tier"
-            } else {
-                "higher tier"
-            };
-            println!(
-                "  {YELLOW}{:>30}{RESET}  ->  {GREEN}{:<22}{RESET} {DIM}({} · probable save ${:.2} ({:.0}%)){RESET}",
-                truncate(&r.model, 30),
-                alt_name,
-                tier_note,
-                save,
-                pct
-            );
-            println!(
-                "  {:>30}  {DIM}   same work would have cost ${:.2} instead of ${:.2}{RESET}",
-                "", alt_cost, r.cost
-            );
-            suggested_ok += 1;
-        }
-    }
-
-    if suggested_ok == 0 {
-        println!("  {GREEN}✓ no waste pattern detected in the last {since_days}d — your tiers match your spend.{RESET}");
-    } else {
-        println!();
-        println!(
-            "  {DIM}heuristic: tiers from public coding evals, costs = your exact token mix{RESET}"
-        );
-        println!(
-            "  {DIM}at those prices. quality isn't guaranteed — run one task as an A/B and{RESET}"
-        );
-        println!("  {DIM}compare before rewiring your whole workflow.{RESET}");
-    }
-    println!();
-}
-
-fn truncate(s: &str, max: usize) -> String {
-    if s.len() <= max {
-        s.to_string()
-    } else {
-        format!("{}…", &s[..max - 1])
-    }
-}

package/src/args.rs

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