faberwright 0.4.0 → 0.4.1

package/dist/pricing.js

@@ -50,6 +50,14 @@ export function normalizeModelId(id) {
 function cacheFile() {
     return path.join(os.homedir(), ".faber", "cache", "prices.json");
 }
+/**
+ * Bumped whenever the cached shape gains a field Faber relies on. A cache
+ * written by an older version is discarded rather than trusted: after adding
+ * `mode` and `supported_endpoints`, a stale file looked complete but carried
+ * neither, so Responses-only models were routed to the wrong endpoint and
+ * failed with a 404 that looked like a Faber bug.
+ */
+export const PRICE_CACHE_VERSION = 2;
 /** Wait this long before retrying after a failed refresh. */
 export const RETRY_AFTER_FAILURE_MS = 24 * 60 * 60 * 1000;
 /** How old the cached prices are, in days. undefined = never fetched. */
@@ -66,7 +74,11 @@ export function pricesAreStale(now = Date.now()) {
 export function readPriceCache() {
     try {
         const raw = JSON.parse(fs.readFileSync(cacheFile(), "utf8"));
-        return raw.prices && typeof raw.prices === "object" ? raw : undefined;
+        if (!raw.prices || typeof raw.prices !== "object")
+            return undefined;
+        if ((raw.version ?? 1) < PRICE_CACHE_VERSION)
+            return undefined; // stale shape
+        return raw;
     }
     catch {
         return undefined;
@@ -77,7 +89,7 @@ export function writePriceCache(prices, source, etag) {
         const f = cacheFile();
         fs.mkdirSync(path.dirname(f), { recursive: true });
         const now = Date.now();
-        fs.writeFileSync(f, JSON.stringify({ fetchedAt: now, lastAttempt: now, source, etag, prices }, null, 2));
+        fs.writeFileSync(f, JSON.stringify({ version: PRICE_CACHE_VERSION, fetchedAt: now, lastAttempt: now, source, etag, prices }, null, 2));
     }
     catch { /* best effort */ }
 }
@@ -103,6 +115,7 @@ export function markRefreshAttempt(now = Date.now()) {
         fs.mkdirSync(path.dirname(f), { recursive: true });
         const existing = readPriceCache();
         fs.writeFileSync(f, JSON.stringify({
+            version: PRICE_CACHE_VERSION,
             fetchedAt: existing?.fetchedAt ?? 0,
             lastAttempt: now,
             source: existing?.source ?? "none",
@@ -214,6 +227,11 @@ export async function refreshPrices(url = DATASET_URL, opts = {}) {
             // and these values get written to a file people read.
             const perM = (n) => Math.round(n * 1e6 * 1e6) / 1e6;
             const price = { in: perM(inC), out: perM(outC) };
+            if (typeof v["mode"] === "string")
+                price.mode = v["mode"];
+            const eps = v["supported_endpoints"];
+            if (Array.isArray(eps))
+                price.endpoints = eps.filter((e) => typeof e === "string");
             const cr = v["cache_read_input_token_cost"], cw = v["cache_creation_input_token_cost"];
             if (typeof cr === "number")
                 price.cacheRead = perM(cr);

package/dist/prompt.js

@@ -17,17 +17,48 @@ async function selectRaw(rl, question, options, defaultIndex = 0) {
         const n = Number.parseInt(ans, 10);
         return Number.isInteger(n) && n >= 1 && n <= options.length ? n - 1 : defaultIndex;
     }
-    console.log(pc.bold(question) + pc.dim("   ↑/↓ then Enter, or 1-9"));
+    // Long lists (a provider can return dozens of models) are unusable with
+    // arrow keys alone, so typing filters the list as you go.
+    const searchable = options.length > 8;
+    console.log(pc.bold(question) +
+        pc.dim(searchable ? "   ↑/↓ then Enter · type to filter" : "   ↑/↓ then Enter, or 1-9"));
     return new Promise((resolve) => {
-        let idx = defaultIndex;
-        let firstRender = true;
+        let filter = "";
+        let view = options.map((_, i) => i); // indices currently shown
+        let cursor = Math.max(0, view.indexOf(defaultIndex));
+        let painted = 0; // rows drawn last time
+        const applyFilter = () => {
+            const q = filter.toLowerCase();
+            const next = options
+                .map((o, i) => [o, i])
+                .filter(([o]) => o.toLowerCase().includes(q))
+                .map(([, i]) => i);
+            view = next.length ? next : [];
+            cursor = 0;
+        };
         const render = () => {
-            if (!firstRender)
-                process.stdout.write(`\x1b[${options.length}A`);
-            firstRender = false;
-            for (let i = 0; i < options.length; i++) {
+            if (painted)
+                process.stdout.write(`\x1b[${painted}A`);
+            const rows = view.length ? view.length : 1;
+            const extra = filter ? 1 : 0;
+            for (let r = 0; r < view.length; r++) {
                 process.stdout.write("\x1b[2K");
-                process.stdout.write((i === idx ? pc.cyan(`❯ ${options[i]}`) : pc.dim(`  ${options[i]}`)) + "\n");
+                const i = view[r];
+                process.stdout.write((r === cursor ? pc.cyan(`❯ ${options[i]}`) : pc.dim(`  ${options[i]}`)) + "\n");
+            }
+            if (!view.length) {
+                process.stdout.write("\x1b[2K" + pc.yellow(`  no match for "${filter}"`) + "\n");
+            }
+            if (filter) {
+                process.stdout.write("\x1b[2K" + pc.dim(`  filter: ${filter}`) + "\n");
+            }
+            // clear any rows the previous, longer render left behind
+            for (let r = rows + extra; r < painted; r++)
+                process.stdout.write("\x1b[2K\n");
+            painted = Math.max(rows + extra, painted);
+            if (painted > rows + extra) {
+                process.stdout.write(`\x1b[${painted - (rows + extra)}A`);
+                painted = rows + extra;
             }
         };
         const stdin = process.stdin;
@@ -58,24 +89,45 @@ async function selectRaw(rl, question, options, defaultIndex = 0) {
                     key = s[i];
                     i += 1;
                 }
-                if (key === "\x1b[A" || key === "k") {
-                    idx = (idx - 1 + options.length) % options.length;
+                if (key === "\x1b[A") {
+                    if (view.length)
+                        cursor = (cursor - 1 + view.length) % view.length;
                     render();
                 }
-                else if (key === "\x1b[B" || key === "j") {
-                    idx = (idx + 1) % options.length;
+                else if (key === "\x1b[B") {
+                    if (view.length)
+                        cursor = (cursor + 1) % view.length;
                     render();
                 }
-                else if (key >= "1" && key <= "9" && Number(key) <= options.length) {
-                    idx = Number(key) - 1;
-                    render();
-                    finish(idx);
-                    done = true;
-                }
                 else if (key === "\r" || key === "\n") {
-                    finish(idx);
+                    if (view.length) {
+                        finish(view[cursor]);
+                        done = true;
+                    }
+                }
+                else if (key === "\x7f" || key === "\b") { // backspace edits the filter
+                    if (filter) {
+                        filter = filter.slice(0, -1);
+                        applyFilter();
+                        render();
+                    }
+                }
+                // Number shortcuts only while unfiltered; once you're typing, digits
+                // are part of the search term (model ids are full of them).
+                else if (!filter && !searchable && key >= "1" && key <= "9" && Number(key) <= options.length) {
+                    finish(Number(key) - 1);
                     done = true;
                 }
+                else if (searchable && key >= " " && key !== "\x1b") {
+                    filter += key;
+                    applyFilter();
+                    render();
+                }
+                else if (!searchable && (key === "k" || key === "j")) {
+                    if (view.length)
+                        cursor = (cursor + (key === "k" ? -1 : 1) + view.length) % view.length;
+                    render();
+                }
                 // Ctrl-C or Esc cancels. Returning -1 used to leak out as an array
                 // index, crashing the caller with "cannot read properties of
                 // undefined" — a cancel must be a clean exit, not a bad index.
@@ -118,7 +170,16 @@ export async function readSecret(rl, promptText, io) {
             resolve(value.trim());
         };
         const onData = (buf) => {
-            for (const ch of buf.toString("utf8")) {
+            // Terminals wrap pasted text in bracketed-paste markers, ESC[200~ before
+            // and ESC[201~ after. The ESC byte is below space and gets dropped by the
+            // printable test below, but "[200~" is ordinary text and would be glued
+            // onto the secret — which is how a pasted key ends up rejected as
+            // malformed. Strip the markers, and any other escape sequence, first.
+            const chunk = buf.toString("utf8")
+                .replace(/\x1b\[20[01]~/g, "")
+                .replace(/\x1b\[[0-9;]*[A-Za-z~]/g, "")
+                .replace(/\x1b./g, "");
+            for (const ch of chunk) {
                 if (ch === "\r" || ch === "\n")
                     return done();
                 if (ch === "\x03") {
@@ -126,16 +187,15 @@ export async function readSecret(rl, promptText, io) {
                     return done();
                 } // Ctrl-C
                 if (ch === "\x7f" || ch === "\b") { // backspace
-                    if (value.length) {
+                    if (value.length)
                         value = value.slice(0, -1);
-                        stdout.write("\b \b");
-                    }
                     continue;
                 }
-                if (ch >= " ") {
+                // Echo nothing at all, the way sudo and ssh do. Masking characters
+                // would still reveal the key's length, and a hundred dots for a long
+                // key looks like something went wrong.
+                if (ch >= " ")
                     value += ch;
-                    stdout.write("•");
-                }
             }
         };
         stdin.on("data", onData);

package/dist/usage.js

@@ -9,7 +9,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { DatabaseSync } from "node:sqlite";
-import { priceFor, cacheReadPrice, cacheWritePrice, PRICES_AS_OF, readPriceCache, priceAgeDays, STALE_AFTER_DAYS } from "./pricing.js";
+import { priceFor, cacheReadPrice, cacheWritePrice, PRICES_AS_OF, readPriceCache } from "./pricing.js";
 export class UsageLedger {
     projectPath;
     db;
@@ -34,6 +34,11 @@ export class UsageLedger {
             }
             catch { /* already migrated */ }
         }
+        // Seven time windows each filter on ts, so make that lookup cheap.
+        try {
+            this.db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_ts ON tasks(ts)");
+        }
+        catch { /* fine */ }
         this.registerProject();
     }
     /**
@@ -146,100 +151,140 @@ export class UsageLedger {
 const k = (n) => n >= 1_000_000 ? (n / 1_000_000).toFixed(1) + "M"
     : n >= 1000 ? (n / 1000).toFixed(1) + "k" : String(n);
 const money = (v) => v === undefined ? "—" : `$${v.toFixed(2)}`;
+/** Cents below a dollar — 3.4¢ reads better than $0.034. */
+const cents = (usd) => usd < 1 ? `${(usd * 100).toFixed(1)}¢` : `$${usd.toFixed(2)}`;
+/** "gpt-5.3-codex", not a 40-character regional deployment id. */
+function shortModel(id) {
+    return id
+        .replace(/^(global|us|eu|apac|au|jp)\./, "")
+        .replace(/^anthropic\./, "")
+        .replace(/-v\d+:\d+$/, "")
+        // "claude-haiku-4-5-20251001" -> "haiku-4-5": the vendor is already known
+        // from the route, and a mid-word truncation reads as a different model.
+        .replace(/^claude-/, "")
+        .replace(/-\d{8}$/, "")
+        .slice(0, 15);
+}
+const DAY = 86_400_000;
 /**
- * Render the /usage panel. Each row is priced per model using that model's own
- * rates, so a history that spans a switch from Sonnet to Opus stays accurate.
+ * Rolling windows, not calendar ones.
+ *
+ * "This month" means one day on the 1st and thirty on the 31st, and it resets
+ * overnight — two figures side by side aren't comparable. Rolling windows
+ * always cover the span they name.
  */
-export function renderUsagePanel(ledger, override) {
-    const midnight = new Date();
+function windows(now) {
+    const midnight = new Date(now);
     midnight.setHours(0, 0, 0, 0);
-    const windows = [
-        ["this session", undefined],
+    return [
         ["today", midnight.getTime()],
+        ["last 7 days", now - 7 * DAY],
+        ["last 14 days", now - 14 * DAY],
+        ["last 30 days", now - 30 * DAY],
+        ["last 3 months", now - 91 * DAY],
+        ["last 6 months", now - 182 * DAY],
         ["all time", 0],
     ];
-    const lines = [];
-    const W = [13, 7, 12, 9, 7, 9, 9];
-    const cells = (c) => c.map((s, i) => s.padEnd(W[i])).join(" ");
-    lines.push(cells(["", "tasks", "in", "cached", "out", "cost", "saved"]));
-    let anyPriced = false;
-    let legacyRows = 0;
+}
+/** Sum a set of per-model bands into one row, pricing anything unrecorded. */
+function rollUp(bands, override) {
+    const totals = { input: 0, cacheRead: 0, cacheWrite: 0, output: 0, calls: 0, tasks: 0 };
+    let cost;
+    let saved;
+    let unpriced = 0;
     let estimated = false;
-    for (const [label, since] of windows) {
-        // session totals come from memory; the rest are priced per model from disk
-        // Every window is priced per model — including the session, which would
-        // otherwise apply the last-used model's rates to earlier tasks.
-        const bands = ledger.totalsByModel(since ?? ledger.startedAt);
-        const agg = { input: 0, cacheRead: 0, cacheWrite: 0, output: 0, calls: 0, tasks: 0 };
-        let cost;
-        let saved;
-        for (const b of bands) {
-            agg.input += b.totals.input;
-            agg.cacheRead += b.totals.cacheRead;
-            agg.cacheWrite += b.totals.cacheWrite;
-            agg.output += b.totals.output;
-            agg.calls += b.totals.calls;
-            agg.tasks += b.totals.tasks;
-            // Historical cost is whatever was charged at the time — never repriced.
-            if (b.billed.cost !== null) {
-                cost = (cost ?? 0) + b.billed.cost;
-                anyPriced = true;
-            }
-            if (b.billed.saved !== null)
-                saved = (saved ?? 0) + b.billed.saved;
-            if (b.billed.unpriced > 0) {
-                // Rows recorded before costs were stored have nothing to preserve, so
-                // estimate them at today's prices and flag the row as an estimate.
-                legacyRows += b.billed.unpriced;
-                const p = priceFor(b.model, override);
-                const c = UsageLedger.cost(b.totals, p);
-                const s = UsageLedger.saved(b.totals, p);
-                if (c !== undefined) {
-                    cost = (cost ?? 0) + c;
-                    anyPriced = true;
-                    estimated = true;
-                }
-                if (s !== undefined)
-                    saved = (saved ?? 0) + s;
+    for (const b of bands) {
+        totals.input += b.totals.input;
+        totals.cacheRead += b.totals.cacheRead;
+        totals.cacheWrite += b.totals.cacheWrite;
+        totals.output += b.totals.output;
+        totals.calls += b.totals.calls;
+        totals.tasks += b.totals.tasks;
+        if (b.billed.cost !== null)
+            cost = (cost ?? 0) + b.billed.cost;
+        if (b.billed.saved !== null)
+            saved = (saved ?? 0) + b.billed.saved;
+        if (b.billed.unpriced > 0) {
+            // Tasks recorded before costs were stored have nothing to preserve, so
+            // estimate them at today's rates rather than showing a gap.
+            unpriced += b.billed.unpriced;
+            const p = priceFor(b.model, override);
+            const c = UsageLedger.cost(b.totals, p);
+            const s = UsageLedger.saved(b.totals, p);
+            if (c !== undefined) {
+                cost = (cost ?? 0) + c;
+                estimated = true;
             }
+            if (s !== undefined)
+                saved = (saved ?? 0) + s;
         }
-        const totalIn = agg.input + agg.cacheRead + agg.cacheWrite;
-        const pct = totalIn > 0 ? Math.round((agg.cacheRead / totalIn) * 100) + "%" : "0%";
-        lines.push(cells([label, String(agg.tasks), k(totalIn), pct, k(agg.output),
-            money(cost), money(saved)]));
     }
-    if (anyPriced) {
-        const src = readPriceCache();
-        lines.push("");
-        lines.push("cost is what each task was charged when it ran — later price changes don't rewrite it");
-        const age = priceAgeDays();
-        if (src && age !== undefined) {
-            const when = new Date(src.fetchedAt).toISOString().slice(0, 10);
-            lines.push(age > STALE_AFTER_DAYS
-                ? `new tasks priced from rates fetched ${when} (${Math.round(age)} days ago — consider /usage --refresh-prices)`
-                : `new tasks priced from rates fetched ${when}`);
-        }
-        else {
-            lines.push(`new tasks priced from built-in rates, as of ${PRICES_AS_OF} — /usage --refresh-prices for current`);
-        }
-        if (legacyRows) {
-            lines.push(`${legacyRows} older task(s) predate cost tracking${estimated ? " — estimated at today's rates" : ""}`);
-        }
+    return { totals, cost, saved, unpriced, estimated };
+}
+/**
+ * The /usage panel for this project.
+ *
+ * Seven fixed windows, never collapsed even when identical: a missing row
+ * would read as "no data" when it actually means "nothing new since", and
+ * that distinction is exactly what someone returning after a break wants.
+ *
+ * The two columns nobody can interpret unaided — cached and saved — are
+ * defined underneath. A metric a reader has to guess at gets ignored.
+ */
+export function renderUsagePanel(ledger, override, now = Date.now()) {
+    const W = [15, 7, 9, 8, 7, 8, 9];
+    const cell = (c) => c.map((s, i) => (i === c.length - 1 ? s : s.padEnd(W[i]))).join(" ").trimEnd();
+    const pad = " ".repeat(W[0]);
+    const lines = [path.basename(ledger.projectPath), ""];
+    lines.push(cell(["", "tasks", "in", "cached", "out", "cost", "saved"]));
+    let allTime = rollUp([], override);
+    for (const [label, since] of windows(now)) {
+        const r = rollUp(ledger.totalsByModel(since), override);
+        const totalIn = r.totals.input + r.totals.cacheRead + r.totals.cacheWrite;
+        lines.push(cell([
+            label, String(r.totals.tasks), k(totalIn),
+            totalIn > 0 ? `${Math.round((r.totals.cacheRead / totalIn) * 100)}%` : "0%",
+            k(r.totals.output), money(r.cost), money(r.saved),
+        ]));
+        if (label === "all time")
+            allTime = r;
     }
-    else {
-        lines.push("");
-        lines.push("no price known for this model — set FABER_PRICE_IN / FABER_PRICE_OUT");
+    lines.push("");
+    if (allTime.cost !== undefined && allTime.totals.tasks > 0) {
+        lines.push(pad + `${cents(allTime.cost / allTime.totals.tasks)} per task`);
+    }
+    lines.push(pad + "cached = input reused from cache, billed at ~10%");
+    if (allTime.cost !== undefined && allTime.saved !== undefined && allTime.saved > 0) {
+        lines.push(pad +
+            `saved  = caching cost you ${money(allTime.cost)} instead of ${money(allTime.cost + allTime.saved)}`);
+    }
+    const src = readPriceCache();
+    lines.push(pad + (src
+        ? `rates ${new Date(src.fetchedAt).toISOString().slice(0, 10)} · /usage --refresh-prices`
+        : `built-in rates, as of ${PRICES_AS_OF} · /usage --refresh-prices`));
+    if (allTime.unpriced > 0) {
+        lines.push(pad +
+            `${allTime.unpriced} older task(s) predate cost tracking${allTime.estimated ? ", estimated" : ""}`);
     }
-    const others = UsageLedger.allProjects().filter((p) => p.totals.tasks > 0);
-    if (others.length > 1) {
+    // Where the money goes. Only models actually used appear, because this is
+    // built from recorded tasks rather than a catalogue.
+    const byModel = ledger.totalsByModel(0)
+        .filter((b) => b.totals.tasks > 0)
+        .map((b) => {
+        const r = rollUp([b], override);
+        return { model: b.model, totals: r.totals, cost: r.cost };
+    })
+        .sort((a, b) => (b.cost ?? 0) - (a.cost ?? 0));
+    if (byModel.length > 1) {
         lines.push("");
-        lines.push("across all projects:");
-        for (const { project, totals: t } of others) {
-            const totalIn = t.input + t.cacheRead + t.cacheWrite;
-            lines.push(cells([
-                "  " + path.basename(project).slice(0, 11), String(t.tasks), k(totalIn),
-                totalIn > 0 ? Math.round((t.cacheRead / totalIn) * 100) + "%" : "0%",
-                k(t.output), "", "",
+        lines.push(cell(["by model", "tasks", "in", "cached", "out", "cost", "per task"]));
+        for (const b of byModel) {
+            const totalIn = b.totals.input + b.totals.cacheRead + b.totals.cacheWrite;
+            lines.push(cell([
+                shortModel(b.model), String(b.totals.tasks), k(totalIn),
+                totalIn > 0 ? `${Math.round((b.totals.cacheRead / totalIn) * 100)}%` : "0%",
+                k(b.totals.output), money(b.cost),
+                b.cost !== undefined ? cents(b.cost / b.totals.tasks) : "—",
             ]));
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "faberwright",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Faber: an agentic AI coding assistant for your terminal — streams, edits with diff approval, runs your tests, and remembers your project across sessions.",
   "type": "module",
   "license": "Apache-2.0",