@cruxy/cli 1.2.0 → 1.3.0

package/dist/usage/weighted.js

@@ -0,0 +1,77 @@
+/**
+ * Weighted tokens (C.22) — the unit the cruxy gateway actually meters a
+ * subscriber in.
+ *
+ * A subscriber is not billed per token and not billed in dollars: the gateway
+ * counts `(billable_input + output) × multiplier` per request and checks that
+ * against two windows. This module computes THAT number, locally, from figures
+ * already on disk — so `cruxy usage` can state consumption in the same unit the
+ * meter uses instead of a currency nobody is charged in.
+ *
+ * WHAT THIS IS NOT: it is not headroom, and it must never be rendered as such.
+ * A cap needs the user's plan, and how much of that plan every OTHER surface
+ * (web chat, desktop, phone) has already spent — neither of which is on this
+ * machine. All this module can honestly say is "this is what the runs in this
+ * CLI's own store weigh". Anything phrased as remaining/left/available would be
+ * a number this process cannot possibly know.
+ *
+ * No network: the multipliers are a compiled-in constant, not a fetched one.
+ */
+/**
+ * Weighted-token multipliers, keyed by tier — mirroring `multipliers` in the
+ * gateway's `internal/budget/config.go`, which is the source of truth.
+ *
+ * MIRRORED, THEREFORE DRIFTABLE. Nothing checks these against the server at
+ * runtime (that would be a network call this module is forbidden to make), so a
+ * gateway-side reweighting silently makes an old CLI's arithmetic stale. That
+ * is the accepted cost of computing offline, and it is why every rendering of
+ * this figure is framed as what THIS CLI reckons it used — never as an
+ * authoritative balance. If they drift, the server is right and this is wrong.
+ *
+ * Only the chat tiers are listed. The gateway also weighs its embed/guard/rerank
+ * models at 0.1×, but the CLI's chat path cannot produce a request on one, so
+ * including them would model traffic that never reaches this store.
+ */
+export const TIER_MULTIPLIERS = {
+    mira: 1.0,
+    vaani: 3.25,
+    kavi: 3.8,
+};
+/** The multiplier for a tier, or `undefined` when the tier isn't a known one. */
+export function multiplierForTier(tier) {
+    return TIER_MULTIPLIERS[tier];
+}
+/**
+ * Weighted tokens for one request's figures, or `undefined` when the request
+ * cannot be weighed honestly.
+ *
+ * BOTH terms are required, and this is the whole discipline of the function.
+ * The meter's formula has two addends; substituting 0 for an unknown one does
+ * not produce an approximate answer, it produces a confidently understated one —
+ * and understating consumption is the direction that flatters, so it is exactly
+ * the error that would go unnoticed. `costFor` could price one known side
+ * because the raw token counts stayed visible beside it; here the weighted
+ * figure IS the deliverable, so a partial one is worse than none. Callers count
+ * the `undefined`s and surface them instead.
+ *
+ * Three ways a request is unweighable, all of them real and all treated alike:
+ *  - no tier, or a tier this build doesn't know (a non-cruxy provider — those
+ *    tokens never touched the weighted pool, so weighing them would be fiction);
+ *  - no `billable_input_tokens` (a gateway too old to send it). Note that
+ *    `inputTokens` is NOT a fallback: it includes cache-read tokens, which the
+ *    meter excludes, so it would overstate every cached request — the precise
+ *    inverse of the caching win the field exists to show;
+ *  - no output count.
+ *
+ * A reported `0` on either side is a real measurement and weighs in as 0.
+ */
+export function weightedFor(tier, billableInputTokens, outputTokens) {
+    if (tier === undefined)
+        return undefined;
+    const multiplier = multiplierForTier(tier);
+    if (multiplier === undefined)
+        return undefined;
+    if (billableInputTokens === undefined || outputTokens === undefined)
+        return undefined;
+    return (billableInputTokens + outputTokens) * multiplier;
+}

package/dist/utils/git.js

@@ -1,4 +1,4 @@
-import { spawnSync } from "node:child_process";
+import { execFile, spawnSync } from "node:child_process";
 /** Hard ceiling on a git invocation; a hung git must never stall startup. */
 const GIT_TIMEOUT_MS = 5000;
 /**
@@ -17,6 +17,35 @@ function runGit(args, cwd) {
     }
     return res.stdout;
 }
+/**
+ * {@link runGit} without blocking the event loop. Same contract in every other
+ * respect: `null` on any failure, never throws, same timeout.
+ *
+ * This exists because `spawnSync` is measurably expensive — around 45ms warm for
+ * the branch+status pair — and the TUI needs this data while a model response is
+ * streaming. Blocking the loop for 45ms mid-stream stutters the paint; blocking
+ * it from the paint path itself would do so on every frame.
+ */
+function runGitAsync(args, cwd) {
+    return new Promise((resolve) => {
+        execFile("git", args, { cwd, encoding: "utf8", timeout: GIT_TIMEOUT_MS, windowsHide: true }, (err, stdout) => resolve(err ? null : stdout));
+    });
+}
+/**
+ * Number of changed paths in `git status --porcelain` output.
+ *
+ * One line is one path, INCLUDING a rename (`R  old -> new`), which is one
+ * change and not two. Blank lines are ignored so a trailing newline — always
+ * present on non-empty output — cannot inflate the count by one.
+ */
+export function countChanges(status) {
+    return status.split("\n").filter((line) => line.trim() !== "").length;
+}
+/** Shared shaping so the sync and async paths cannot disagree. */
+function toGitInfo(branch, status) {
+    const changed = countChanges(status);
+    return { branch: branch.trim(), dirty: changed > 0, changed };
+}
 /**
  * Branch name plus the raw `git status --porcelain` text for `cwd`, or `null`
  * when it isn't a git repository (or git is unavailable). Backs the `git_status`
@@ -32,12 +61,29 @@ export function getGitStatus(cwd) {
     return { branch: branch.trim(), status };
 }
 /**
- * Compact git context for the system prompt: current branch and whether the
- * working tree has uncommitted changes. `null` when not a repo / git missing.
+ * Compact git context for the system prompt: current branch, whether the working
+ * tree has uncommitted changes, and how many paths changed. `null` when not a
+ * repo / git missing.
+ *
+ * The change count costs no extra subprocess — it is derived from the porcelain
+ * output {@link getGitStatus} already fetched.
  */
 export function getGitInfo(cwd) {
     const info = getGitStatus(cwd);
     if (info === null)
         return null;
-    return { branch: info.branch, dirty: info.status.trim().length > 0 };
+    return toGitInfo(info.branch, info.status);
+}
+/**
+ * {@link getGitInfo} without blocking the event loop — what the TUI rail uses.
+ * Identical result, identical `null` semantics.
+ */
+export async function getGitInfoAsync(cwd) {
+    const branch = await runGitAsync(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
+    if (branch === null)
+        return null;
+    const status = await runGitAsync(["status", "--porcelain"], cwd);
+    if (status === null)
+        return null;
+    return toGitInfo(branch, status);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cruxy/cli",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "an agentic coding CLI",
   "type": "module",
   "bin": {
@@ -36,7 +36,7 @@
     "undici": "^6.21.0",
     "zod": "^3.23.8",
     "zod-to-json-schema": "^3.23.5",
-    "@cruxy/sdk": "0.4.0"
+    "@cruxy/sdk": "0.4.1"
   },
   "optionalDependencies": {
     "better-sqlite3": "^12.11.1"

package/dist/usage/cost.js

@@ -1,29 +0,0 @@
-/**
- * Token → cost mapping (C.22). The whole discipline lives in one rule: a cost is
- * produced ONLY when the tier has a configured price AND at least one token side
- * is known. Otherwise the result is `undefined` — cost is omitted, tokens are
- * still shown, and NO dollar figure is ever fabricated. Prices are per MILLION
- * tokens (see {@link TierPrice}). Keyed by tier only (U.8 gag). No network.
- */
-/** The configured price for a tier, or `undefined` when the tier is unpriced. */
-export function priceForTier(tier, prices) {
-    return prices[tier];
-}
-/**
- * Compute the cost of a tier's usage, or `undefined` when it cannot be stated
- * honestly:
- *  - no configured price for the tier → `undefined` (cost omitted).
- *  - both token counts unknown → `undefined` (nothing real to price).
- * A known side is priced; an unknown side contributes nothing (never a
- * fabricated 0-token charge). tokens/1e6 × price, summed.
- */
-export function costFor(tier, inputTokens, outputTokens, prices) {
-    const price = priceForTier(tier, prices);
-    if (!price)
-        return undefined;
-    if (inputTokens === undefined && outputTokens === undefined)
-        return undefined;
-    const inCost = inputTokens !== undefined ? (inputTokens / 1_000_000) * price.input : 0;
-    const outCost = outputTokens !== undefined ? (outputTokens / 1_000_000) * price.output : 0;
-    return inCost + outCost;
-}