@praeviso/code-env-switch 0.1.4 → 0.1.6

package/src/statusline/usage/codex.ts

@@ -0,0 +1,258 @@
+import type {
+    StatuslineInput,
+    StatuslineInputUsage,
+    StatuslineUsageTotals,
+} from "../types";
+import { coerceNumber, firstNumber, isRecord } from "../utils";
+
+function resolveOutputTokens(record: Record<string, unknown>): number | null {
+    const outputTokens =
+        firstNumber(
+            record.outputTokens,
+            record.output,
+            record.output_tokens
+        ) ?? null;
+    const reasoningTokens =
+        firstNumber(
+            record.reasoning_output_tokens,
+            record.reasoningOutputTokens,
+            record.reasoning_output
+        ) ?? null;
+    if (outputTokens !== null) return outputTokens;
+    if (reasoningTokens !== null) return reasoningTokens;
+    return null;
+}
+
+function splitInputTokens(
+    record: Record<string, unknown>
+): { inputTokens: number | null; cacheReadTokens: number | null } {
+    const rawInput =
+        firstNumber(
+            record.inputTokens,
+            record.input,
+            record.input_tokens
+        ) ?? null;
+    const cacheRead =
+        firstNumber(
+            record.cached_input_tokens,
+            record.cachedInputTokens,
+            record.cache_read_input_tokens,
+            record.cacheReadInputTokens,
+            record.cache_read,
+            record.cacheRead
+        ) ?? null;
+    if (rawInput === null) {
+        return { inputTokens: null, cacheReadTokens: cacheRead };
+    }
+    if (cacheRead === null) {
+        return { inputTokens: rawInput, cacheReadTokens: null };
+    }
+    const nonCachedInput = Math.max(0, rawInput - cacheRead);
+    return { inputTokens: nonCachedInput, cacheReadTokens: cacheRead };
+}
+
+function parseCodexUsageTotalsRecord(
+    record: Record<string, unknown>
+): StatuslineUsageTotals | null {
+    const split = splitInputTokens(record);
+    const inputTokens = split.inputTokens;
+    const outputTokens = resolveOutputTokens(record);
+    const cacheRead = split.cacheReadTokens;
+    const cacheWrite =
+        firstNumber(
+            record.cache_creation_input_tokens,
+            record.cacheCreationInputTokens,
+            record.cache_write_input_tokens,
+            record.cacheWriteInputTokens,
+            record.cache_write,
+            record.cacheWrite
+        ) ?? null;
+    const totalTokens =
+        firstNumber(
+            record.totalTokens,
+            record.total,
+            record.total_tokens
+        ) ?? null;
+    let computedTotal: number | null = null;
+    if (
+        inputTokens !== null ||
+        outputTokens !== null ||
+        cacheRead !== null ||
+        cacheWrite !== null
+    ) {
+        computedTotal =
+            (inputTokens || 0) +
+            (outputTokens || 0) +
+            (cacheRead || 0) +
+            (cacheWrite || 0);
+    }
+    const resolvedTotal = totalTokens ?? computedTotal;
+    if (
+        inputTokens === null &&
+        outputTokens === null &&
+        cacheRead === null &&
+        cacheWrite === null &&
+        resolvedTotal === null
+    ) {
+        return null;
+    }
+    return {
+        inputTokens,
+        outputTokens,
+        cacheReadTokens: cacheRead,
+        cacheWriteTokens: cacheWrite,
+        totalTokens: resolvedTotal,
+    };
+}
+
+function parseCodexInputUsageRecord(
+    record: Record<string, unknown>
+): StatuslineInputUsage | null {
+    const todayTokens =
+        firstNumber(
+            record.todayTokens,
+            record.today,
+            record.today_tokens,
+            record.daily,
+            record.daily_tokens
+        ) ?? null;
+    const totalTokens =
+        firstNumber(
+            record.totalTokens,
+            record.total,
+            record.total_tokens
+        ) ?? null;
+    const split = splitInputTokens(record);
+    const inputTokens = split.inputTokens;
+    const outputTokens = resolveOutputTokens(record);
+    const cacheRead = split.cacheReadTokens;
+    const cacheWrite =
+        firstNumber(
+            record.cache_creation_input_tokens,
+            record.cacheCreationInputTokens,
+            record.cache_write_input_tokens,
+            record.cacheWriteInputTokens,
+            record.cache_write,
+            record.cacheWrite
+        ) ?? null;
+    if (
+        todayTokens === null &&
+        totalTokens === null &&
+        inputTokens === null &&
+        outputTokens === null &&
+        cacheRead === null &&
+        cacheWrite === null
+    ) {
+        return null;
+    }
+    const hasCacheTokens = cacheRead !== null || cacheWrite !== null;
+    const computedTotal = hasCacheTokens
+        ? (inputTokens || 0) +
+          (outputTokens || 0) +
+          (cacheRead || 0) +
+          (cacheWrite || 0)
+        : null;
+    const resolvedTodayTokens = hasCacheTokens
+        ? todayTokens ?? totalTokens ?? computedTotal
+        : todayTokens;
+    return {
+        todayTokens: resolvedTodayTokens,
+        totalTokens: totalTokens ?? null,
+        inputTokens,
+        outputTokens,
+        cacheReadTokens: cacheRead,
+        cacheWriteTokens: cacheWrite,
+    };
+}
+
+function resolveNestedRecord(
+    record: Record<string, unknown>,
+    ...keys: string[]
+): Record<string, unknown> | null {
+    for (const key of keys) {
+        if (isRecord(record[key])) {
+            return record[key] as Record<string, unknown>;
+        }
+    }
+    return null;
+}
+
+export function getCodexUsageTotalsFromInput(
+    input: StatuslineInput | null
+): StatuslineUsageTotals | null {
+    if (!input) return null;
+    const tokenUsage = input.token_usage;
+    if (typeof tokenUsage === "number") {
+        return {
+            inputTokens: null,
+            outputTokens: null,
+            cacheReadTokens: null,
+            cacheWriteTokens: null,
+            totalTokens: coerceNumber(tokenUsage),
+        };
+    }
+    if (isRecord(tokenUsage)) {
+        const totalUsage = resolveNestedRecord(
+            tokenUsage,
+            "total_token_usage",
+            "totalTokenUsage"
+        );
+        if (totalUsage) {
+            const parsed = parseCodexUsageTotalsRecord(totalUsage);
+            if (parsed) return parsed;
+        }
+        const parsed = parseCodexUsageTotalsRecord(tokenUsage as Record<string, unknown>);
+        if (parsed) return parsed;
+    }
+    if (isRecord(input.usage)) {
+        return parseCodexUsageTotalsRecord(input.usage as Record<string, unknown>);
+    }
+    return null;
+}
+
+export function getCodexInputUsage(
+    input: StatuslineInput | null
+): StatuslineInputUsage | null {
+    if (!input) return null;
+    if (isRecord(input.usage)) {
+        const parsed = parseCodexInputUsageRecord(input.usage as Record<string, unknown>);
+        if (parsed) return parsed;
+        return input.usage as StatuslineInputUsage;
+    }
+    const tokenUsage = input.token_usage;
+    if (tokenUsage !== null && tokenUsage !== undefined) {
+        if (typeof tokenUsage === "number") {
+            return {
+                todayTokens: null,
+                totalTokens: coerceNumber(tokenUsage),
+                inputTokens: null,
+                outputTokens: null,
+                cacheReadTokens: null,
+                cacheWriteTokens: null,
+            };
+        }
+        if (isRecord(tokenUsage)) {
+            const totalUsage = resolveNestedRecord(
+                tokenUsage,
+                "total_token_usage",
+                "totalTokenUsage"
+            );
+            if (totalUsage) {
+                const parsed = parseCodexInputUsageRecord(totalUsage);
+                if (parsed) return parsed;
+            }
+            const lastUsage = resolveNestedRecord(
+                tokenUsage,
+                "last_token_usage",
+                "lastTokenUsage"
+            );
+            if (lastUsage) {
+                const parsed = parseCodexInputUsageRecord(lastUsage);
+                if (parsed) return parsed;
+            }
+            const parsed = parseCodexInputUsageRecord(tokenUsage as Record<string, unknown>);
+            if (parsed) return parsed;
+        }
+    }
+    return null;
+}

package/src/statusline/usage.ts

@@ -2,127 +2,26 @@ import type { Config } from "../types";
 import { normalizeType } from "../profile/type";
 import { readUsageTotalsIndex, resolveUsageTotalsForProfile } from "../usage";
 import type { StatuslineInput, StatuslineInputUsage, StatuslineUsage, StatuslineUsageTotals } from "./types";
-import { coerceNumber, firstNumber, isRecord } from "./utils";
-
-export function parseUsageTotalsRecord(
-    record: Record<string, unknown>
-): StatuslineUsageTotals | null {
-    const inputTokens =
-        firstNumber(
-            record.inputTokens,
-            record.input,
-            record.input_tokens
-        ) ?? null;
-    const outputTokens =
-        firstNumber(
-            record.outputTokens,
-            record.output,
-            record.output_tokens
-        ) ?? null;
-    const totalTokens =
-        firstNumber(
-            record.totalTokens,
-            record.total,
-            record.total_tokens
-        ) ?? null;
-    const cacheRead =
-        firstNumber(
-            record.cache_read_input_tokens,
-            record.cacheReadInputTokens,
-            record.cache_read,
-            record.cacheRead
-        ) ?? null;
-    const cacheWrite =
-        firstNumber(
-            record.cache_creation_input_tokens,
-            record.cacheCreationInputTokens,
-            record.cache_write_input_tokens,
-            record.cacheWriteInputTokens,
-            record.cache_write,
-            record.cacheWrite
-        ) ?? null;
-    let computedTotal: number | null = null;
-    if (
-        inputTokens !== null ||
-        outputTokens !== null ||
-        cacheRead !== null ||
-        cacheWrite !== null
-    ) {
-        computedTotal =
-            (inputTokens || 0) +
-            (outputTokens || 0) +
-            (cacheRead || 0) +
-            (cacheWrite || 0);
-    }
-    const resolvedTotal = totalTokens ?? computedTotal;
-    if (
-        inputTokens === null &&
-        outputTokens === null &&
-        resolvedTotal === null
-    ) {
-        return null;
-    }
-    return {
-        inputTokens,
-        outputTokens,
-        totalTokens: resolvedTotal,
-    };
-}
+import { coerceNumber } from "./utils";
+import { getClaudeUsageTotalsFromInput } from "./usage/claude";
+import { getCodexUsageTotalsFromInput } from "./usage/codex";
 
 export function getUsageTotalsFromInput(
-    input: StatuslineInput | null
+    input: StatuslineInput | null,
+    type: string | null
 ): StatuslineUsageTotals | null {
     if (!input) return null;
-    const contextWindow = isRecord(input.context_window)
-        ? (input.context_window as Record<string, unknown>)
-        : isRecord(input.contextWindow)
-        ? (input.contextWindow as Record<string, unknown>)
-        : null;
-    if (contextWindow) {
-        const totalInputTokens =
-            firstNumber(
-                contextWindow.total_input_tokens,
-                contextWindow.totalInputTokens
-            ) ?? null;
-        const totalOutputTokens =
-            firstNumber(
-                contextWindow.total_output_tokens,
-                contextWindow.totalOutputTokens
-            ) ?? null;
-        if (totalInputTokens !== null || totalOutputTokens !== null) {
-            return {
-                inputTokens: totalInputTokens,
-                outputTokens: totalOutputTokens,
-                totalTokens: (totalInputTokens || 0) + (totalOutputTokens || 0),
-            };
-        }
-    }
-    if (typeof input.token_usage === "number") {
-        return {
-            inputTokens: null,
-            outputTokens: null,
-            totalTokens: coerceNumber(input.token_usage),
-        };
-    }
-    if (isRecord(input.token_usage)) {
-        const tokenUsage = input.token_usage as Record<string, unknown>;
-        const totalUsage =
-            (isRecord(tokenUsage.total_token_usage)
-                ? (tokenUsage.total_token_usage as Record<string, unknown>)
-                : null) ||
-            (isRecord(tokenUsage.totalTokenUsage)
-                ? (tokenUsage.totalTokenUsage as Record<string, unknown>)
-                : null);
-        if (totalUsage) {
-            const parsed = parseUsageTotalsRecord(totalUsage);
-            if (parsed) return parsed;
-        }
-        return parseUsageTotalsRecord(tokenUsage);
+    const normalized = normalizeType(type || "");
+    if (normalized === "codex") {
+        return getCodexUsageTotalsFromInput(input);
     }
-    if (isRecord(input.usage)) {
-        return parseUsageTotalsRecord(input.usage as Record<string, unknown>);
+    if (normalized === "claude") {
+        return getClaudeUsageTotalsFromInput(input);
     }
-    return null;
+    return (
+        getCodexUsageTotalsFromInput(input) ||
+        getClaudeUsageTotalsFromInput(input)
+    );
 }
 
 export function normalizeInputUsage(
@@ -131,15 +30,19 @@ export function normalizeInputUsage(
     if (!inputUsage) return null;
     const usage: StatuslineUsage = {
         todayTokens: coerceNumber(inputUsage.todayTokens),
-        totalTokens: coerceNumber(inputUsage.totalTokens),
+        totalTokens: coerceNumber(inputUsage.totalTokens),  
         inputTokens: coerceNumber(inputUsage.inputTokens),
         outputTokens: coerceNumber(inputUsage.outputTokens),
+        cacheReadTokens: coerceNumber(inputUsage.cacheReadTokens),
+        cacheWriteTokens: coerceNumber(inputUsage.cacheWriteTokens),
     };
     const hasUsage =
         usage.todayTokens !== null ||
         usage.totalTokens !== null ||
         usage.inputTokens !== null ||
-        usage.outputTokens !== null;
+        usage.outputTokens !== null ||
+        usage.cacheReadTokens !== null ||
+        usage.cacheWriteTokens !== null;
     return hasUsage ? usage : null;
 }
 
@@ -166,8 +69,10 @@ export function resolveUsageFromRecords(
         return {
             todayTokens: usage.today,
             totalTokens: usage.total,
-            inputTokens: null,
-            outputTokens: null,
+            inputTokens: usage.todayInput ?? null,
+            outputTokens: usage.todayOutput ?? null,
+            cacheReadTokens: usage.todayCacheRead ?? null,
+            cacheWriteTokens: usage.todayCacheWrite ?? null,
         };
     } catch {
         return null;

package/src/types.ts

@@ -15,6 +15,7 @@ export interface Profile {
     env?: Record<string, EnvValue>;
     removeFiles?: string[];
     commands?: string[];
+    pricing?: ProfilePricing;
 }
 
 export interface CodexStatuslineConfig {
@@ -43,6 +44,24 @@ export interface Config {
     claudeSessionsPath?: string;
     codexStatusline?: CodexStatuslineConfig;
     claudeStatusline?: ClaudeStatuslineConfig;
+    pricing?: PricingConfig;
+}
+
+export interface TokenPricing {
+    input?: number;
+    output?: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+    description?: string;
+}
+
+export interface PricingConfig {
+    models?: Record<string, TokenPricing>;
+}
+
+export interface ProfilePricing extends TokenPricing {
+    model?: string;
+    multiplier?: number;
 }
 
 export interface ListRow {
@@ -54,6 +73,10 @@ export interface ListRow {
     usageType?: ProfileType | null;
     todayTokens?: number;
     totalTokens?: number;
+    todayCost?: number;
+    totalCost?: number;
+    todayBilledTokens?: number;
+    totalBilledTokens?: number;
 }
 
 export interface ParsedArgs {
@@ -78,6 +101,10 @@ export interface AddArgs {
     type: ProfileType | null;
 }
 
+export interface UsageResetArgs {
+    yes: boolean;
+}
+
 export type StatuslineFormat = "text" | "json";
 
 export interface StatuslineArgs {