@hasna/statusline 0.0.7 → 0.0.9

package/dist/context-window.d.ts

@@ -7,8 +7,30 @@ export interface ContextUsage {
     /** Context window size in tokens. */
     window: number;
 }
+/** The raw `message.usage` object of the last assistant entry that carries one. */
+export interface UsageBlock {
+    input_tokens: number;
+    cache_creation_input_tokens?: number;
+    cache_read_input_tokens?: number;
+    output_tokens?: number;
+}
+/**
+ * Scan the session transcript (JSONL) from the end and return the raw usage
+ * block of the last assistant entry that carries one — the block that
+ * reflects what the context window currently holds. Lines that are malformed
+ * or whose usage block lacks a numeric `input_tokens` are skipped, exactly
+ * like `contextUsage` used to skip them inline.
+ */
+export declare function lastUsageBlock(ctx: StatusContext): UsageBlock | null;
 /**
  * Derive context usage from the session transcript (JSONL). The last
  * assistant entry's usage block reflects what the context window holds.
  */
 export declare function contextUsage(ctx: StatusContext): ContextUsage | null;
+/**
+ * Fraction of input-side tokens served from cache, dispatched on the
+ * context's provider: the Claude transcript usage block, the Codex session
+ * rollout's latest token_count, or the OpenCode sessions DB. Null when the
+ * source is absent or the divisor is zero — never a wrong number.
+ */
+export declare function cacheRate(ctx: StatusContext): number | null;

package/dist/disk.d.ts

@@ -0,0 +1,51 @@
+import type { RenderMemo, SegmentColor } from "./providers/types.js";
+/** The statfs fields this module needs; node's StatFs carries more. */
+export interface DiskStats {
+    bsize: number;
+    blocks: number;
+    bavail: number;
+}
+/** Injectable reader: tests pass a fake, the render uses the real syscall. */
+export type DiskStatfsReader = (path: string) => DiskStats | null;
+export interface DiskFree {
+    freeBytes: number;
+    totalBytes: number;
+    /** Blocks available to an unprivileged user, as a percentage. */
+    freePercent: number;
+}
+/** Below 20% free a disk is worth flagging; below 10% it is critical. */
+export declare const DISK_WARN_PERCENT = 20;
+export declare const DISK_CRITICAL_PERCENT = 10;
+export type DiskLevel = "low" | "critical";
+/**
+ * Read a filesystem's stats with one syscall. Returns null when the runtime
+ * has no `statfs` or the call fails (missing path, permission, unsupported
+ * filesystem), so the caller can omit the segment instead of guessing.
+ */
+export declare function readDiskStats(path: string): DiskStats | null;
+/**
+ * Free bytes for `path`'s volume, or null when the reading is unusable.
+ *
+ * Unreadable or missing fields are null, never zero: a rendered zero has to
+ * mean "the disk really is full", not "this runtime could not tell me".
+ */
+export declare function diskFree(path: string, reader?: DiskStatfsReader): DiskFree | null;
+/**
+ * Free space for `path`, read at most once per render.
+ *
+ * The memo belongs to a single `renderLine` call and is shared by a segment's
+ * text and colour, so the volume is read once instead of once per consumer. It
+ * is discarded when that render ends: the next invocation reads afresh, so this
+ * is not a cache and cannot show a figure from a previous render.
+ */
+export declare function diskFreeFor(path: string, memo?: RenderMemo, reader?: DiskStatfsReader): DiskFree | null;
+/** Severity for a free percentage; null while the volume has headroom. */
+export declare function diskLevel(freePercent: number): DiskLevel | null;
+/**
+ * `disk 24G` while healthy, `disk 8.2G low` below the warning line. The
+ * textual marker is deliberate: colour alone disappears under `NO_COLOR`,
+ * where a nearly-full disk still has to be visible at a glance.
+ */
+export declare function formatDiskFree(disk: DiskFree): string;
+/** Healthy disks stay dim; low space escalates yellow, then red. */
+export declare function diskColor(disk: DiskFree | null): SegmentColor | null;

package/dist/format.d.ts

@@ -1,4 +1,11 @@
 export declare function compactAge(seconds: number): string;
 export declare function compactNum(n: number): string;
+/**
+ * Byte count in binary units, one decimal at most: `461k`, `24.1G`, `512B`.
+ * Unit letters match `df -h` (K/M/G/T are 1024-based here) so the number
+ * agrees with what an operator sees in a shell. An unusable value — negative,
+ * NaN, Infinity — returns "" rather than a plausible-looking number.
+ */
+export declare function compactBytes(bytes: number): string;
 export declare function money(n: number): string;
 export declare function compactDuration(ms: number): string;

package/dist/index.d.ts

@@ -1,10 +1,12 @@
 import { type StatuslineConfig } from "./config.js";
 export { sessionAccount, sessionAccountEmail, sessionConfigDir, sessionStateFile, type SessionAccount, } from "./accounts.js";
 export { defaultConfig, loadConfig, saveConfig, configPath, type StatuslineConfig } from "./config.js";
-export { contextUsage, type ContextUsage } from "./context-window.js";
+export { cacheRate, contextUsage, lastUsageBlock, type ContextUsage, type UsageBlock } from "./context-window.js";
 export { compactAge, compactDuration, compactNum, money } from "./format.js";
 export { gitBranch, gitProjectName, gitRoot, lastCommitEpoch, trackedLineCount } from "./git.js";
 export { claudeSettingsPath, installClaude } from "./install.js";
+export { codexCacheRate, latestCodexSessionPath, type TotalTokenUsage } from "./providers/codex.js";
+export { opencodeCacheRate, type OpenCodeCacheRateOptions } from "./providers/opencode.js";
 export { parseClaudeInput } from "./providers/claude.js";
 export type { Segment, SegmentColor, StatusContext } from "./providers/types.js";
 export { renderLine } from "./render.js";