@archeagle087/costcrew 0.0.0-stage → 0.4.0

package/install.sh

@@ -0,0 +1,56 @@
+#!/bin/sh
+# costcrew installer — curl -fsSL https://raw.githubusercontent.com/Arch087146/costcrew/main/install.sh | sh
+set -eu
+
+REPO="Arch087146/costcrew"
+VERSION="${COSTCREW_VERSION:-latest}"
+
+# pick the asset for this machine
+OS="$(uname -s)"
+ARCH="$(uname -m)"
+case "$OS" in
+    Darwin) OS_TAG="macos" ;;
+    Linux) OS_TAG="linux" ;;
+    *) echo "unsupported OS: $OS (windows users: use install.ps1)" >&2; exit 1 ;;
+esac
+case "$ARCH" in
+    arm64 | aarch64) ARCH_TAG="aarch64" ;;
+    x86_64 | amd64) ARCH_TAG="x86_64" ;;
+    *) echo "unsupported arch: $ARCH" >&2; exit 1 ;;
+esac
+ASSET="costcrew-${OS_TAG}-${ARCH_TAG}.tar.gz"
+
+if [ "$VERSION" = "latest" ]; then
+    URL="https://github.com/${REPO}/releases/latest/download/${ASSET}"
+else
+    URL="https://github.com/${REPO}/releases/download/${VERSION}/${ASSET}"
+fi
+
+# install destination: writable dir on PATH, else ~/.local/bin
+if [ -n "${COSTCREW_INSTALL_DIR:-}" ]; then
+    DEST="$COSTCREW_INSTALL_DIR"
+elif [ -w /usr/local/bin ] 2>/dev/null; then
+    DEST="/usr/local/bin"
+else
+    DEST="${HOME}/.local/bin"
+    mkdir -p "$DEST"
+    case ":$PATH:" in
+        *":$DEST:"*) ;;
+        *) echo "note: add $DEST to your PATH:  export PATH=\"\$HOME/.local/bin:\$PATH\"" ;;
+    esac
+fi
+
+TMP="$(mktemp -d)"
+trap 'rm -rf "$TMP"' EXIT
+
+echo "fetching ${ASSET} ..."
+curl -fsSL "$URL" -o "$TMP/costcrew.tar.gz"
+tar xzf "$TMP/costcrew.tar.gz" -C "$TMP"
+
+mv "$TMP/costcrew" "$DEST/costcrew"
+chmod +x "$DEST/costcrew"
+
+echo
+echo "installed: $(command -v costcrew 2>/dev/null || echo "$DEST/costcrew")"
+"$DEST/costcrew" --version
+echo "run  costcrew  to open the app · costcrew prices · costcrew spend"

package/package.json

@@ -1,6 +1,20 @@
 {
   "name": "@archeagle087/costcrew",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.4.0",
+  "description": "The AI coding price database, plus what you spend on it — interactive terminal app. Bundled 465+ model prices, your spend ledger, arena leaderboard priced elo-per-dollar.",
+  "bin": {
+    "costcrew": "bin.js"
+  },
+  "optionalDependencies": {
+    "@archeagle087/costcrew-win32-x64": "0.4.0",
+    "@archeagle087/costcrew-linux-x64": "0.4.0",
+    "@archeagle087/costcrew-darwin-arm64": "0.4.0",
+    "@archeagle087/costcrew-darwin-x64": "0.4.0"
+  },
+  "os": ["win32", "linux", "darwin"],
+  "cpu": ["x64", "arm64"],
+  "keywords": ["ai", "llm", "cost", "tokens", "pricing", "claude", "opencode", "cli"],
+  "license": "MIT",
+  "repository": "github:Arch087146/costcrew",
+  "homepage": "https://github.com/Arch087146/costcrew#readme"
+}

package/packaging/npm/bin.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+// costcrew npm wrapper: finds the platform binary installed as an
+// optionalDependency and execs it with all arguments passed through.
+"use strict";
+const { spawnSync } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+
+const PLATFORMS = {
+  "win32-x64": "@archeagle087/costcrew-win32-x64/costcrew.exe",
+  "linux-x64": "@archeagle087/costcrew-linux-x64/costcrew",
+  "darwin-arm64": "@archeagle087/costcrew-darwin-arm64/costcrew",
+  "darwin-x64": "@archeagle087/costcrew-darwin-x64/costcrew",
+};
+
+const key = `${process.platform}-${process.arch}`;
+const rel = PLATFORMS[key];
+if (!rel) {
+  console.error(`costcrew: no prebuilt binary for ${key}`);
+  console.error("build from source: https://github.com/Arch087146/costcrew");
+  process.exit(1);
+}
+
+function resolveBinary() {
+  const direct = path.join(__dirname, "..", rel);
+  if (fs.existsSync(direct)) return direct;
+  // npm can hoist/reshape optionalDependencies — fall back to resolution
+  const [pkg, file] = rel.split("/");
+  try {
+    const dir = path.dirname(require.resolve(`${pkg}/package.json`, { paths: [__dirname] }));
+    return path.join(dir, file);
+  } catch {
+    return direct; // let spawn fail with a clear ENOENT
+  }
+}
+
+const bin = resolveBinary();
+const result = spawnSync(bin, process.argv.slice(2), { stdio: "inherit" });
+if (result.error) {
+  console.error(`costcrew: failed to launch ${bin}: ${result.error.message}`);
+  process.exit(1);
+}
+process.exit(result.status ?? 0);

package/packaging/npm/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@archeagle087/costcrew",
+  "version": "0.4.0",
+  "description": "The AI coding price database, plus what you spend on it — interactive terminal app. Bundled 465+ model prices, your spend ledger, arena leaderboard priced elo-per-dollar.",
+  "bin": {
+    "costcrew": "bin.js"
+  },
+  "optionalDependencies": {
+    "@archeagle087/costcrew-win32-x64": "0.4.0",
+    "@archeagle087/costcrew-linux-x64": "0.4.0",
+    "@archeagle087/costcrew-darwin-arm64": "0.4.0",
+    "@archeagle087/costcrew-darwin-x64": "0.4.0"
+  },
+  "os": ["win32", "linux", "darwin"],
+  "cpu": ["x64", "arm64"],
+  "keywords": ["ai", "llm", "cost", "tokens", "pricing", "claude", "opencode", "cli"],
+  "license": "MIT",
+  "repository": "github:Arch087146/costcrew",
+  "homepage": "https://github.com/Arch087146/costcrew#readme"
+}

package/packaging/winget/0.4.0/Arch087146.costcrew.installer.yaml

@@ -0,0 +1,15 @@
+PackageIdentifier: Arch087146.costcrew
+PackageVersion: 0.4.0
+Installers:
+- Architecture: x64
+  InstallerType: zip
+  InstallerUrl: https://github.com/Arch087146/costcrew/releases/download/v0.4.0/costcrew-windows-x86_64.zip
+  InstallerSha256: 9B4F651A49D49AA338E68C008F33E4CC6D00E50D576026D05E81CB33385367CE
+  NestedInstallerType: portable
+  NestedInstallerFiles:
+  - RelativeFilePath: costcrew.exe
+    PortableCommandAlias: costcrew
+  InstallerSwitches:
+    Portable: ''
+ManifestType: installer
+ManifestVersion: 1.9.0

package/packaging/winget/0.4.0/Arch087146.costcrew.locale.en-US.yaml

@@ -0,0 +1,28 @@
+PackageIdentifier: Arch087146.costcrew
+PackageVersion: 0.4.0
+PackageLocale: en-US
+Publisher: Arch087146
+PublisherUrl: https://github.com/Arch087146
+PackageName: costcrew
+PackageUrl: https://github.com/Arch087146/costcrew
+License: MIT
+LicenseUrl: https://github.com/Arch087146/costcrew/blob/main/LICENSE
+ShortDescription: The AI coding price database, plus what you spend on it.
+Description: |-
+  One binary, two halves. First: a bundled database of what every AI model
+  costs - every input/output/cache rate per 1M tokens, works offline, no API
+  key, nothing to configure. Second: your own spend, recorded by you, totaled
+  by month and service, plus provider-reported truth from your API keys.
+  Type `costcrew` for the interactive app; flags like `costcrew prices claude`
+  work for scripting.
+Moniker: costcrew
+Tags:
+- ai
+- llm
+- cost
+- pricing
+- tokens
+- cli
+- rust
+ManifestType: defaultLocale
+ManifestVersion: 1.9.0

package/packaging/winget/0.4.0/Arch087146.costcrew.yaml

@@ -0,0 +1,5 @@
+PackageIdentifier: Arch087146.costcrew
+PackageVersion: 0.4.0
+DefaultLocale: en-US
+ManifestType: version
+ManifestVersion: 1.9.0

package/packaging/winget/README.md

@@ -0,0 +1,31 @@
+# winget manifests
+
+These three files submit costcrew to the official winget community repo.
+
+## How to submit (one-time per release)
+
+1. Fork https://github.com/microsoft/winget-pkgs
+2. Copy the `0.4.0/` folder (all three YAML files) to
+   `manifests/a/Arch087146/costcrew/0.4.0/` in your fork.
+3. Open a PR against `microsoft/winget-pkgs` with title
+   `Add: Arch087146.costcrew version 0.4.0`.
+4. The PR checks will run winget's manifest validator automatically.
+   Once a maintainer approves, the package goes live and
+   `winget install Arch087146.costcrew` works.
+
+## Updating hashes
+
+`InstallerSha256` in `Arch087146.costcrew.installer.yaml` is the SHA256 of
+`costcrew-windows-x86_64.zip` from release v0.4.0. When a new version is
+released, compute it with:
+
+```powershell
+Get-FileHash .\costcrew-windows-x86_64.zip -Algorithm SHA256
+```
+
+## Validating locally (optional)
+
+```sh
+winget install Microsoft.Winget.SourceValidation
+winget validate --manifest .\0.4.0\
+```

package/scripts/render_screen.py

@@ -0,0 +1,221 @@
+#!/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

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