@praeviso/code-env-switch 0.1.3 → 0.1.5

package/src/statusline/usage/codex.ts

@@ -0,0 +1,263 @@
+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 && reasoningTokens === null) return null;
+    if (reasoningTokens === null) return outputTokens;
+    return (outputTokens || 0) + reasoningTokens;
+}
+
+function parseCodexUsageTotalsRecord(
+    record: Record<string, unknown>
+): StatuslineUsageTotals | null {
+    const inputTokens =
+        firstNumber(
+            record.inputTokens,
+            record.input,
+            record.input_tokens
+        ) ?? null;
+    const outputTokens = resolveOutputTokens(record);
+    const cacheRead =
+        firstNumber(
+            record.cached_input_tokens,
+            record.cachedInputTokens,
+            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;
+    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 inputTokens =
+        firstNumber(
+            record.inputTokens,
+            record.input,
+            record.input_tokens
+        ) ?? null;
+    const outputTokens = resolveOutputTokens(record);
+    const cacheRead =
+        firstNumber(
+            record.cached_input_tokens,
+            record.cachedInputTokens,
+            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;
+    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 lastUsage = resolveNestedRecord(
+            tokenUsage,
+            "last_token_usage",
+            "lastTokenUsage"
+        );
+        if (lastUsage) {
+            const parsed = parseCodexUsageTotalsRecord(lastUsage);
+            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

@@ -0,0 +1,80 @@
+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 } from "./utils";
+import { getClaudeUsageTotalsFromInput } from "./usage/claude";
+import { getCodexUsageTotalsFromInput } from "./usage/codex";
+
+export function getUsageTotalsFromInput(
+    input: StatuslineInput | null,
+    type: string | null
+): StatuslineUsageTotals | null {
+    if (!input) return null;
+    const normalized = normalizeType(type || "");
+    if (normalized === "codex") {
+        return getCodexUsageTotalsFromInput(input);
+    }
+    if (normalized === "claude") {
+        return getClaudeUsageTotalsFromInput(input);
+    }
+    return (
+        getCodexUsageTotalsFromInput(input) ||
+        getClaudeUsageTotalsFromInput(input)
+    );
+}
+
+export function normalizeInputUsage(
+    inputUsage: StatuslineInputUsage | null
+): StatuslineUsage | null {
+    if (!inputUsage) return null;
+    const usage: StatuslineUsage = {
+        todayTokens: coerceNumber(inputUsage.todayTokens),
+        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.cacheReadTokens !== null ||
+        usage.cacheWriteTokens !== null;
+    return hasUsage ? usage : null;
+}
+
+export function resolveUsageFromRecords(
+    config: Config,
+    configPath: string | null,
+    type: string | null,
+    profileKey: string | null,
+    profileName: string | null,
+    syncUsage: boolean
+): StatuslineUsage | null {
+    try {
+        const normalized = normalizeType(type || "");
+        if (!normalized || (!profileKey && !profileName)) return null;
+        const totals = readUsageTotalsIndex(config, configPath, syncUsage);
+        if (!totals) return null;
+        const usage = resolveUsageTotalsForProfile(
+            totals,
+            normalized,
+            profileKey,
+            profileName
+        );
+        if (!usage) return null;
+        return {
+            todayTokens: usage.today,
+            totalTokens: usage.total,
+            inputTokens: usage.todayInput ?? null,
+            outputTokens: usage.todayOutput ?? null,
+            cacheReadTokens: usage.todayCacheRead ?? null,
+            cacheWriteTokens: usage.todayCacheWrite ?? null,
+        };
+    } catch {
+        return null;
+    }
+}

package/src/statusline/utils.ts

@@ -0,0 +1,27 @@
+export function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function firstNonEmpty(...values: Array<string | null | undefined>): string | null {
+    for (const value of values) {
+        if (value === null || value === undefined) continue;
+        const text = String(value).trim();
+        if (text) return text;
+    }
+    return null;
+}
+
+export function coerceNumber(value: unknown): number | null {
+    if (value === null || value === undefined || value === "") return null;
+    const num = Number(value);
+    if (!Number.isFinite(num)) return null;
+    return num;
+}
+
+export function firstNumber(...values: Array<unknown>): number | null {
+    for (const value of values) {
+        const num = coerceNumber(value);
+        if (num !== null) return num;
+    }
+    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 {