@cruxy/cli 1.3.0 → 1.5.0

package/dist/tui/git-view.js

@@ -0,0 +1,121 @@
+import { formatStat } from "../render/diff.js";
+import { fitMiddle } from "../render/layout.js";
+/** Verb column, fixed width so the paths align into a scannable column. */
+const VERBS = {
+    added: "added",
+    modified: "modified",
+    deleted: "deleted",
+    renamed: "renamed",
+    untracked: "new",
+    conflicted: "conflict",
+};
+const VERB_COLS = 8;
+/**
+ * How many files to list per root before summarising the rest.
+ *
+ * A cap rather than the whole list because a `node_modules` accident produces
+ * thousands of untracked paths, and a pane that has to be scrolled past them to
+ * reach the next root is worse than one that says how many it held back. The
+ * remainder is COUNTED, never silently dropped.
+ */
+export const GIT_VIEW_MAX_FILES = 200;
+/** Colour by what happened, so the shape of a change is legible before the path. */
+function styleVerb(status, theme) {
+    const verb = VERBS[status].padEnd(VERB_COLS);
+    switch (status) {
+        case "deleted":
+            return theme.danger(verb);
+        case "added":
+        case "untracked":
+            return theme.success(verb);
+        case "conflicted":
+            return theme.warning(verb);
+        default:
+            return theme.muted(verb);
+    }
+}
+/** `modified src/x.ts  +12/-3` — verb, path, then the counts when known. */
+function fileRow(file, theme, cols) {
+    const stat = formatStat(file, theme);
+    // The path is middle-truncated so the basename — the part that identifies the
+    // file — survives a narrow pane, the same rule `render/diff.ts` applies.
+    const room = Math.max(8, cols - VERB_COLS - 2 - (stat === "" ? 0 : 9));
+    const path = fitMiddle(file.path, room, theme.glyph.ellipsis);
+    return `${styleVerb(file.status, theme)} ${path}${stat === "" ? "" : ` ${stat}`}`;
+}
+/** One root's block: its heading, then its files or why there are none. */
+function rootLines(root, theme, cols, multiRoot) {
+    const lines = [];
+    if (multiRoot) {
+        const mark = root.primary ? theme.accent(theme.glyph.pointer) : " ";
+        lines.push(`${mark} ${theme.strong(root.name)}`);
+    }
+    // The tri-state, drawn as three different sentences. "Not probed" and "not a
+    // repo" are not the same claim, and neither is "clean" — see `status-view.ts`.
+    if (root.state === undefined) {
+        lines.push(theme.muted(`  checking${theme.glyph.ellipsis}`));
+        return lines;
+    }
+    if (root.state === null) {
+        lines.push(theme.muted("  not a git repo"));
+        return lines;
+    }
+    const { branch, files } = root.state;
+    lines.push(`  ${theme.strong(branch)}`);
+    if (files === undefined) {
+        // The cheap probe ran, so dirtiness is known but the list was never asked
+        // for. Say that rather than render an empty list as "nothing changed".
+        lines.push(theme.muted(root.state.changed > 0
+            ? `  ${root.state.changed} changed — file list not loaded`
+            : "  clean"));
+        return lines;
+    }
+    if (files.length === 0) {
+        lines.push(theme.success("  clean"));
+        return lines;
+    }
+    for (const file of files.slice(0, GIT_VIEW_MAX_FILES)) {
+        lines.push(`  ${fileRow(file, theme, Math.max(8, cols - 2))}`);
+    }
+    const hidden = files.length - GIT_VIEW_MAX_FILES;
+    if (hidden > 0) {
+        lines.push(theme.muted(`  ${theme.glyph.ellipsis}${hidden} more`));
+    }
+    return lines;
+}
+/** The whole Git view, as lines. Pure: no probe, no disk, no clock. */
+export function gitViewLines(theme, cols, roots) {
+    const lines = [theme.heading("git")];
+    if (roots.length === 0) {
+        lines.push(theme.muted("no declared roots"));
+        return lines;
+    }
+    const multiRoot = roots.length > 1;
+    for (const root of roots) {
+        lines.push("");
+        lines.push(...rootLines(root, theme, cols, multiRoot));
+    }
+    return lines;
+}
+/**
+ * The Git view as a registered source.
+ *
+ * `roots` is a callback rather than an array so `/add-root` mid-session is
+ * reflected without re-registering the view — the workspace is the owner of
+ * that list, and copying it here would make this the second place it lives.
+ */
+export function createGitView(roots, git) {
+    return {
+        id: "git",
+        label: "git",
+        lines: (theme, cols) => gitViewLines(theme, cols, roots().map((r) => ({
+            name: r.name,
+            primary: r.primary,
+            state: git.current(r.absPath),
+        }))),
+        refresh: async () => {
+            git.invalidate();
+            await git.refresh();
+        },
+    };
+}

package/dist/tui/index.js

@@ -2,8 +2,14 @@ export { budgetColumns, bodyRows, columnOf, composeScreen, droppedForWidth, fitB
 export { COLUMN_LABELS, PANEL_LABELS, contextPanelLines, gitPanelLines, headerModel, modelPanelLines, mainWelcome, railBlocks, sidebarLines, toolsPanelLines, } from "./panels.js";
 export { ContextGauge, readContext, } from "./context-gauge.js";
 export { ToolVersions, parseVersion, } from "./tool-versions.js";
-export { GitStatusCache, } from "./git-status.js";
-export { TuiRenderer, PAINT_INTERVAL_MS, SCROLLBACK_LINES, } from "./renderer.js";
+export { GitStatusCache, WorkspaceGitCache, } from "./git-status.js";
+export { WorkspaceDiskCache } from "./disk-status.js";
+export { createOverviewView } from "./overview.js";
+export { createGitView, gitViewLines, GIT_VIEW_MAX_FILES, } from "./git-view.js";
+export { createTasksView, tasksViewLines, TASKS_VIEW_MAX_JOBS, TASKS_VIEW_TAIL, } from "./tasks-view.js";
+export { createSettingsView, settingsViewLines, formatSettingValue, } from "./settings-view.js";
+export { TuiRenderer, PAINT_INTERVAL_MS, VIEW_PULSE_MS, SCROLL_PAGE_OVERLAP, SCROLLBACK_LINES, } from "./renderer.js";
+export { CONVERSATION_VIEW, cycleView, navLines, viewLabel, viewOrder, } from "./views.js";
 export { runTui, renderInput, TUI_COMMANDS } from "./app.js";
 export { openPalette, paletteItems, paletteInsertion, paletteLabel, } from "./palette.js";
 export { canOverlay, createKeyLease, createOverlayFrame, createOverlayIO, } from "./overlay.js";

package/dist/tui/layout.js

@@ -1,6 +1,7 @@
 import { fit, visibleWidth } from "../render/layout.js";
 export const RAIL_PANELS = [
     "context",
+    "limits",
     "model",
     "git",
     "tools",
@@ -123,6 +124,51 @@ export function fitBlock(lines, rows, width) {
         out.push(" ".repeat(Math.max(0, width)));
     return out;
 }
+/**
+ * Window `rows` lines out of a block, `offset` display lines up from the end
+ * (P7 track 1). `offset === 0` is the tail view {@link fitBlock} gives, and the
+ * two agree line-for-line there.
+ *
+ * The offset is measured from the BOTTOM because that is the edge the user is
+ * anchored to: the live tail is the home position, and "how far back am I" is
+ * the question both the clamp and the notice need answered. Measuring from the
+ * top would make every append renumber the position.
+ *
+ * Clamping belongs here rather than at the key handler because only this
+ * function knows the content: the handler would have to re-derive the wrapped
+ * line count to bound a keypress, which is the calculation this already did.
+ */
+export function scrollWindow(lines, rows, offset) {
+    const visible = Math.max(0, rows);
+    // Everything above the last `visible` lines is reachable, and no further: the
+    // top of the document is the top of the window, never a screen of blank rows
+    // above it.
+    const maxOffset = Math.max(0, lines.length - visible);
+    const clamped = Math.min(Math.max(0, Math.floor(offset)), maxOffset);
+    const end = lines.length - clamped;
+    const start = Math.max(0, end - visible);
+    return {
+        lines: lines.slice(start, end),
+        offset: clamped,
+        hiddenBelow: clamped,
+        hiddenAbove: start,
+    };
+}
+/**
+ * The scrollback notice: how far back the view is, and how to get out of it.
+ *
+ * Shown only while scrolled, and it costs a row from the window rather than
+ * overlaying one — the same trade {@link stackPanels} makes for its overflow
+ * notice, for the same reason: silently hiding a line to report hidden lines
+ * would be the one dishonest way to draw this.
+ *
+ * It names the key because a scrolled view is a mode, and a mode the user
+ * cannot see the exit from is a trap — there is no scrollbar here to drag.
+ */
+export function scrollNotice(hiddenBelow, theme) {
+    const glyph = theme.unicode ? "↓" : "v";
+    return theme.warning(`${glyph} ${hiddenBelow} more line${hiddenBelow === 1 ? "" : "s"} below · PgDn / Esc to return`);
+}
 /** Rows the overflow notice costs when at least one panel is dropped. */
 const OVERFLOW_ROWS = 1;
 /**

package/dist/tui/limits-panel.js

@@ -0,0 +1,255 @@
+import { bindingWindow, usedFraction } from "../limits/index.js";
+/**
+ * The limits panel (P9): what this credential may spend, and how much is left.
+ *
+ * THE PANEL IS DRIVEN BY THE BUCKET, NEVER BY THE LOGIN. Which numbers exist —
+ * and whether a fraction exists at all — is decided by the billing bucket the
+ * gateway reports, because that is the only thing that actually decides it. The
+ * inference this replaces (a CLI login is an apikey, so it is metered and
+ * ungated) was true when it was written and silently stopped being true when the
+ * gateway changed what a login mints (cruxy-ai/api#174), with nothing locally
+ * observable changing. So there are four bodies here, one per shape, and the
+ * type system hands each of them only the numbers that shape may state.
+ *
+ * AND THIS ONE GETS A BAR. The context panel refuses one under a locking test,
+ * for reasons that are exactly right there: its numerator is a chars/4 estimate
+ * and its denominator a local config default, so a filled bar would render a
+ * guess as a measurement. Every number here is the opposite — server-authored,
+ * in the meter's own unit, peeked from the same buckets the gate enforces on, so
+ * the fraction the bar fills IS the fraction the next request is judged against.
+ * A bar is the right claim for a real measurement, and only for one.
+ *
+ * The corollary is the rule the rest of this file exists to keep: NO CAP, NO
+ * FRACTION. An enterprise pool reports `{enforced: false}` and a developer key
+ * reports `metered: true`; neither has an allowance, so neither gets a bar, a
+ * percentage, or an X-of-Y — not even a reassuring full one. Spend caps are not
+ * a substitute, because they appear only when someone set one.
+ */
+/** Cells in the bar. Sized so `bar + " " + "100%"` clears {@link RAIL_COLS}. */
+const BAR_CELLS = 12;
+/**
+ * A proportion bar. Empty under the screen-reader glyph table (both cells are
+ * ""), which is deliberate — a run of blocks announces as nothing, and the
+ * percentage that follows it carries the entire meaning.
+ */
+export function bar(theme, fraction, cells = BAR_CELLS) {
+    const filled = Math.round(Math.min(1, Math.max(0, fraction)) * cells);
+    return (theme.glyph.barFilled.repeat(filled) +
+        theme.glyph.barEmpty.repeat(cells - filled));
+}
+/**
+ * The styler for a window's state. `low` and `blocked` are the two the user can
+ * act on, and they are different acts — one is "wrap up", the other is "you are
+ * already being refused" — so they are not merged into one warning.
+ */
+function stateStyle(theme, state) {
+    if (state === "blocked")
+        return theme.danger;
+    if (state === "low")
+        return theme.warning;
+    return theme.strong;
+}
+/** 14_000_000 → "14M", 8_700_000 → "8.7M", 125_000 → "125k", 900 → "900". */
+export function compactTokens(n) {
+    const abs = Math.abs(n);
+    if (abs >= 1_000_000)
+        return `${trimZero(n / 1_000_000)}M`;
+    if (abs >= 1_000)
+        return `${trimZero(n / 1_000)}k`;
+    return `${Math.round(n)}`;
+}
+/** One decimal, but only when it says something: 8.7 stays, 14.0 becomes 14. */
+function trimZero(n) {
+    const one = n.toFixed(1);
+    return one.endsWith(".0") ? one.slice(0, -2) : one;
+}
+/** 27.77 → "$27.77", 29 → "$29", 0.5 → "$0.50". */
+export function usd(n) {
+    return Number.isInteger(n) ? `$${n}` : `$${n.toFixed(2)}`;
+}
+/**
+ * How long until an ISO instant, compactly: "18d", "4h", "12m", "now".
+ * `undefined` for an absent or unparseable one — a reset we cannot state is
+ * simply not stated, never guessed at.
+ */
+export function untilLabel(iso, now) {
+    if (!iso)
+        return undefined;
+    const at = Date.parse(iso);
+    if (Number.isNaN(at))
+        return undefined;
+    const ms = at - now;
+    if (ms <= 0)
+        return "now";
+    const minutes = Math.floor(ms / 60_000);
+    if (minutes < 60)
+        return `${Math.max(1, minutes)}m`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h`;
+    return `${Math.floor(hours / 24)}d`;
+}
+/** A percentage for display: 0.618 → "62%". */
+function pct(fraction) {
+    return `${Math.round(fraction * 100)}%`;
+}
+/**
+ * Beyond this, the reading is called out as old rather than presented as
+ * current. The pool is shared with every other surface on the account, so an
+ * idle CLI's figures can go stale without this process doing anything at all —
+ * which is precisely the case a timestamp has to cover.
+ */
+const STALE_AFTER_MS = 5 * 60_000;
+/**
+ * The subscription pool: a bar on the BINDING window, the same one the gate
+ * decides against.
+ *
+ * Drawing the month instead — the bigger, friendlier number — would routinely
+ * show a comfortable 6% while the trailing-12h burst, a quarter of the month's
+ * cap on every self-serve tier, is the window actually about to refuse the next
+ * request. The bar is the thing that stops you, and the line under it names
+ * which window that is so the figure is never ambiguous.
+ */
+function poolLines(theme, pool, now) {
+    const binding = bindingWindow(pool.monthly, pool.burst);
+    // Unreachable via `reduceLimits` (a pool with no readable window reduces to
+    // `unknown`), but the type permits it and inventing a bar is the one thing
+    // this panel must never do on the way to being defensive.
+    if (!binding)
+        return [theme.muted("figures not reported")];
+    const { window: w, name } = binding;
+    const fraction = usedFraction(w) ?? 0;
+    const style = stateStyle(theme, w.state ?? pool.state);
+    const lines = [
+        `${style(bar(theme, fraction))} ${style(pct(fraction))}`,
+        `${compactTokens(w.used)} / ${compactTokens(w.cap)} ${name}`,
+    ];
+    // The window that is NOT binding, so both dimensions are visible — a user
+    // whose burst is tight still needs to know the month is nearly gone too.
+    const other = name === "burst" ? pool.monthly : pool.burst;
+    const otherName = name === "burst" ? "month" : "burst";
+    const until = untilLabel(w.resetsAt, now);
+    if (other) {
+        const otherPct = pct(usedFraction(other) ?? 0);
+        lines.push(theme.muted(until
+            ? `${otherName} ${otherPct} ${theme.sep}${until}`
+            : `${otherName} ${otherPct}`));
+    }
+    else if (until) {
+        lines.push(theme.muted(`resets ${until}`));
+    }
+    // Only when it is actionable. A blocked model list is the answer to "why did
+    // that request fail"; mira's remaining requests are the answer to "what can I
+    // still run" — and neither question is being asked while the pool is healthy.
+    if (pool.blockedModels.length > 0) {
+        lines.push(theme.danger(`no ${pool.blockedModels.join(" ")}`));
+    }
+    else if (pool.state === "low" && pool.mira) {
+        lines.push(theme.muted(`mira ${compactTokens(pool.mira.remaining)} left`));
+    }
+    return lines;
+}
+/** A spend cap line. Text, never a bar: the bar belongs to the allowance. */
+function spendCapLine(theme, label, cap) {
+    return theme.muted(`${label} ${usd(cap.remaining)} of ${usd(cap.cap)}`);
+}
+/** How long ago, compactly: the mirror of {@link untilLabel}. */
+function agoLabel(ms) {
+    const minutes = Math.floor(ms / 60_000);
+    if (minutes < 60)
+        return `${Math.max(1, minutes)}m`;
+    const hours = Math.floor(minutes / 60);
+    return hours < 24 ? `${hours}h` : `${Math.floor(hours / 24)}d`;
+}
+/** The body for a ready reading, chosen by the budget shape. */
+function readingLines(theme, reading, now) {
+    const lines = [];
+    const budget = reading.budget;
+    switch (budget.kind) {
+        case "pool":
+            lines.push(...poolLines(theme, budget, now));
+            break;
+        // Enterprise. NO fraction, and no consolation bar drawn at 0% either: a full
+        // green bar and "no limit" are read the same way at a glance, and only one
+        // of them is true.
+        case "unenforced":
+            lines.push(theme.strong(reading.tier));
+            lines.push(theme.muted("pool not enforced"));
+            break;
+        // A developer key: billed per token, gated by nothing it draws down. Saying
+        // "no pool" explicitly matters here — an empty budget section would read as
+        // a figure that failed to load rather than as a figure that does not exist.
+        case "metered":
+            lines.push(`${theme.strong(reading.tier)}${theme.muted(" metered")}`);
+            lines.push(theme.muted("no pool cap"));
+            break;
+        case "credits": {
+            const fraction = budget.granted > 0
+                ? Math.min(1, Math.max(0, budget.used / budget.granted))
+                : undefined;
+            if (fraction !== undefined) {
+                const style = fraction >= 0.9 ? theme.warning : theme.strong;
+                lines.push(`${style(bar(theme, fraction))} ${style(pct(fraction))}`);
+            }
+            lines.push(`${usd(budget.remaining)} of ${usd(budget.granted)}`);
+            const until = untilLabel(budget.resetsAt, now);
+            if (until)
+                lines.push(theme.muted(`resets ${until}`));
+            break;
+        }
+        // The bucket, or the pool inside it, is one this build cannot read. Both
+        // facts it DOES have are real and server-resolved, so both are shown; what
+        // it does not have, it declines to imply.
+        case "unknown":
+            lines.push(`${theme.strong(reading.tier)}${theme.muted(` ${theme.glyph.sep} ${reading.bucket}`)}`);
+            lines.push(theme.muted("budget not reported"));
+            break;
+    }
+    // Rate and spend caps hang off every bucket, so they are appended once here
+    // rather than repeated per branch. They are the ONLY ceilings a metered key
+    // has — and they appear only when they exist, which is why they can never
+    // stand in for the pool a metered key does not have.
+    if (budget.kind === "metered" && reading.chat) {
+        const { remaining, limit } = reading.chat.perKey;
+        lines.push(theme.muted(`${remaining} / ${limit} rpm`));
+    }
+    if (reading.keySpendCap) {
+        lines.push(spendCapLine(theme, "key", reading.keySpendCap));
+    }
+    if (reading.workspaceSpendCap) {
+        lines.push(spendCapLine(theme, "ws", reading.workspaceSpendCap));
+    }
+    // The cache keeps the last good reading through a failed refresh, so the panel
+    // owes the user the age of what it is showing rather than the impression that
+    // it is live.
+    const age = now - reading.readAt;
+    if (age > STALE_AFTER_MS) {
+        lines.push(theme.muted(`as of ${agoLabel(age)} ago`));
+    }
+    return lines;
+}
+/**
+ * The limits panel's body.
+ *
+ * `pending` and each error reason are said differently, on the tri-state
+ * discipline the git panel established: "still asking" must not read as "no
+ * limits", and neither may read as "your key is bad".
+ */
+export function limitsPanelLines(theme, state, now = Date.now()) {
+    if (state === undefined || state.status === "pending") {
+        return [theme.muted(`checking${theme.glyph.ellipsis}`)];
+    }
+    if (state.status === "error") {
+        switch (state.reason) {
+            case "unauthenticated":
+                return [theme.muted("not signed in"), theme.muted("run cruxy login")];
+            case "unsupported":
+                // The gateway answered — it simply has no limits to report. Sending this
+                // user to debug their network would be the wrong errand entirely.
+                return [theme.muted("gateway reports"), theme.muted("no limits")];
+            case "unreachable":
+                return [theme.muted("gateway unreachable")];
+        }
+    }
+    return readingLines(theme, state.reading, now);
+}

package/dist/tui/overview.js

@@ -0,0 +1,61 @@
+import { buildSessionStatus } from "../agent/status.js";
+import { sessionStatusLines } from "../render/status-view.js";
+/**
+ * The Overview view (P7 track 3) — the first concrete {@link ViewSource}.
+ *
+ * There is almost nothing here, and that is the result rather than an accident.
+ * `sessionStatusLines` already composed this screen for `/status`, and
+ * `buildSessionStatus` already assembles what it renders; the only thing that
+ * was missing was somewhere for it to LIVE. As a command it printed once into
+ * the scrollback and was gone by the next turn — a standing description of the
+ * session that could not stand.
+ *
+ * LIVE VS PER-PAINT, decided per fact rather than per view:
+ *
+ *  - **Per-paint** — turns, mode, model, served tier, context occupancy,
+ *    sandbox, checkpoints, job counts, tool count. Every one is a field read or
+ *    a filter over an in-memory array, so recomputing them at 30fps costs
+ *    nothing measurable and they are never a frame stale.
+ *  - **Cached, off the paint path** — branch and change count, per root. These
+ *    cost two subprocesses each, ~45ms warm and worse on Windows, and the pane
+ *    repaints on every frame and every resize. {@link WorkspaceGitCache} does
+ *    the probing after a turn; {@link lines} only ever reads the last settled
+ *    value. Free space joins them: microseconds on a local disk, and an
+ *    unbounded kernel block on a network mount that has stopped answering.
+ *
+ * The rule the split enforces: nothing in `lines` may spawn, block, or touch
+ * the disk. Anything that needs to is a cache read here and a `refresh` there.
+ */
+export function createOverviewView(session, git, 
+/**
+ * The tier the gateway last said served a request — a getter, not a value,
+ * because it changes per turn and the view is registered once. Supplied by
+ * the renderer, the only object that sees the stream's routing frame.
+ */
+servedTier = () => undefined, 
+/**
+ * Free space where cruxy writes. Optional so a caller that has no disk cache
+ * gets a status screen without disk rows rather than a probe it didn't ask
+ * for — the same shape `servedTier` uses for a fact only some callers have.
+ */
+disk) {
+    return {
+        id: "overview",
+        label: "overview",
+        lines: (theme, cols) => sessionStatusLines(buildSessionStatus(session, (absPath) => git.current(absPath), servedTier(), disk ? (path) => disk.current(path) : undefined), theme, cols),
+        /**
+         * Re-probe every root after a turn. Invalidate-then-refresh because a turn
+         * is exactly when the tree may have moved; the cache coalesces, so the ten
+         * writes a turn makes still cost one probe per root.
+         *
+         * Disk refreshes alongside, and unconditionally — it has no invalidate,
+         * because free space moves for reasons that have nothing to do with this
+         * session (see `disk-status.ts`). Concurrently, not in sequence: they are
+         * independent reads and neither should wait on the other's slowest mount.
+         */
+        refresh: async () => {
+            git.invalidate();
+            await Promise.all([git.refresh(), disk?.refresh()]);
+        },
+    };
+}

package/dist/tui/panels.js

@@ -17,6 +17,7 @@ import { RAIL_PANELS, } from "./layout.js";
 export const PANEL_LABELS = {
     sidebar: "sidebar",
     context: "context",
+    limits: "limits",
     model: "model",
     git: "git",
     tools: "tools",
@@ -30,6 +31,7 @@ export const COLUMN_LABELS = {
 /** Titles drawn at the top of each rail panel. */
 const RAIL_TITLES = {
     context: "context",
+    limits: "limits",
     model: "model",
     git: "git",
     tools: "tools",