@praeviso/code-env-switch 0.1.4 → 0.1.6

package/src/statusline/format.ts

@@ -1,4 +1,5 @@
 import { formatTokenCount } from "../usage";
+import { formatUsdAmount } from "../usage/pricing";
 import {
     ICON_CONTEXT,
     ICON_CWD,
@@ -9,7 +10,6 @@ import {
     colorize,
     dim,
 } from "./style";
-import type { StatuslineUsage } from "./types";
 import * as path from "path";
 
 export function getCwdSegment(cwd: string): string | null {
@@ -19,15 +19,14 @@ export function getCwdSegment(cwd: string): string | null {
     return dim(segment);
 }
 
-export function formatUsageSegment(usage: StatuslineUsage | null): string | null {
-    if (!usage) return null;
-    const today =
-        usage.todayTokens ??
-        (usage.inputTokens !== null || usage.outputTokens !== null
-            ? (usage.inputTokens || 0) + (usage.outputTokens || 0)
-            : usage.totalTokens);
-    if (today === null) return null;
-    const text = `Today ${formatTokenCount(today)}`;
+export function formatUsageSegment(
+    todayCost: number | null,
+    sessionCost: number | null
+): string | null {
+    if (todayCost === null && sessionCost === null) return null;
+    const todayText = `T ${formatUsdAmount(todayCost)}`;
+    const sessionText = `S ${formatUsdAmount(sessionCost)}`;
+    const text = `${todayText} / ${sessionText}`;
     return colorize(`${ICON_USAGE} ${text}`, "33");
 }
 

package/src/statusline/index.ts

@@ -3,7 +3,13 @@
  */
 import type { Config, StatuslineArgs } from "../types";
 import { normalizeType, inferProfileType, getProfileDisplayName } from "../profile/type";
-import { syncUsageFromStatuslineInput } from "../usage";
+import {
+    readUsageCostIndex,
+    readUsageSessionCost,
+    resolveUsageCostForProfile,
+    syncUsageFromStatuslineInput,
+} from "../usage";
+import { calculateUsageCost, resolvePricingForProfile } from "../usage/pricing";
 import { appendStatuslineDebug } from "./debug";
 import {
     formatContextSegment,
@@ -91,8 +97,17 @@ export function buildStatuslineResult(
     )!;
 
     const sessionId = getSessionId(stdinInput);
-    const stdinUsageTotals = getUsageTotalsFromInput(stdinInput);
     const usageType = normalizeType(type || "");
+    const stdinUsageTotals = getUsageTotalsFromInput(stdinInput, usageType);
+    const model = firstNonEmpty(
+        args.model,
+        process.env.CODE_ENV_MODEL,
+        getModelFromInput(stdinInput)
+    );
+    const modelProvider = firstNonEmpty(
+        process.env.CODE_ENV_MODEL_PROVIDER,
+        getModelProviderFromInput(stdinInput)
+    );
     appendStatuslineDebug(configPath, {
         timestamp: new Date().toISOString(),
         typeCandidate,
@@ -130,20 +145,11 @@ export function buildStatuslineResult(
             profileName,
             sessionId,
             stdinUsageTotals,
-            cwd
+            cwd,
+            model
         );
     }
 
-    const model = firstNonEmpty(
-        args.model,
-        process.env.CODE_ENV_MODEL,
-        getModelFromInput(stdinInput)
-    );
-    const modelProvider = firstNonEmpty(
-        process.env.CODE_ENV_MODEL_PROVIDER,
-        getModelProviderFromInput(stdinInput)
-    );
-
     const usage: StatuslineUsage = {
         todayTokens: firstNumber(
             args.usageToday,
@@ -161,6 +167,8 @@ export function buildStatuslineResult(
             args.usageOutput,
             process.env.CODE_ENV_USAGE_OUTPUT
         ),
+        cacheReadTokens: null,
+        cacheWriteTokens: null,
     };
 
     const hasExplicitUsage =
@@ -169,21 +177,25 @@ export function buildStatuslineResult(
         usage.inputTokens !== null ||
         usage.outputTokens !== null;
 
-    const stdinUsage = normalizeInputUsage(getInputUsage(stdinInput));
+    const stdinUsage = normalizeInputUsage(getInputUsage(stdinInput, usageType));
+    const recordsUsage = resolveUsageFromRecords(
+        config,
+        configPath,
+        type,
+        profileKey,
+        profileName,
+        args.syncUsage
+    );
 
     let finalUsage: StatuslineUsage | null = hasExplicitUsage ? usage : null;
+    if (!finalUsage && args.syncUsage && recordsUsage) {
+        finalUsage = recordsUsage;
+    }
     if (!finalUsage) {
         finalUsage = stdinUsage;
     }
-    if (!finalUsage) {
-        finalUsage = resolveUsageFromRecords(
-            config,
-            configPath,
-            type,
-            profileKey,
-            profileName,
-            args.syncUsage
-        );
+    if (!finalUsage && recordsUsage) {
+        finalUsage = recordsUsage;
     }
 
     let gitStatus = getGitStatus(cwd);
@@ -198,7 +210,45 @@ export function buildStatuslineResult(
     const gitSegment = formatGitSegment(gitStatus);
     const profileSegment = formatProfileSegment(type, profileKey, profileName);
     const modelSegment = formatModelSegment(model, modelProvider);
-    const usageSegment = formatUsageSegment(finalUsage);
+    let profile = profileKey && config.profiles ? config.profiles[profileKey] : null;
+    if (!profile && profileName && config.profiles) {
+        const matches = Object.entries(config.profiles).find(([key, entry]) => {
+            const displayName = getProfileDisplayName(key, entry);
+            return (
+                displayName === profileName ||
+                entry.name === profileName ||
+                key === profileName
+            );
+        });
+        if (matches) profile = matches[1];
+    }
+    const sessionUsage = hasExplicitUsage ? usage : stdinUsage;
+    const pricing = resolvePricingForProfile(config, profile || null, model);
+    let sessionCost: number | null = null;
+    if (hasExplicitUsage) {
+        sessionCost = sessionUsage
+            ? calculateUsageCost(sessionUsage, pricing)
+            : null;
+    } else {
+        const sessionCostFromRecords = sessionId
+            ? readUsageSessionCost(
+                  config,
+                  configPath,
+                  type,
+                  sessionId,
+                  args.syncUsage
+              )
+            : null;
+        sessionCost =
+            sessionCostFromRecords ??
+            (sessionUsage ? calculateUsageCost(sessionUsage, pricing) : null);
+    }
+    const costIndex = readUsageCostIndex(config, configPath, args.syncUsage);
+    const costTotals = costIndex
+        ? resolveUsageCostForProfile(costIndex, type, profileKey, profileName)
+        : null;
+    const todayCost = costTotals ? costTotals.today : null;
+    const usageSegment = formatUsageSegment(todayCost, sessionCost);
     const contextLeft = getContextLeftPercent(stdinInput, type);
     const contextSegment = formatContextSegment(contextLeft);
     const contextUsedTokens = getContextUsedTokens(stdinInput);

package/src/statusline/input.ts

@@ -7,7 +7,9 @@ import type {
     StatuslineInputProfile,
     StatuslineInputUsage,
 } from "./types";
-import { coerceNumber, firstNonEmpty, firstNumber, isRecord } from "./utils";
+import { coerceNumber, firstNonEmpty, isRecord } from "./utils";
+import { getClaudeInputUsage } from "./usage/claude";
+import { getCodexInputUsage } from "./usage/codex";
 
 export function readStdinJson(): StatuslineInput | null {
     if (process.stdin.isTTY) return null;
@@ -83,162 +85,19 @@ export function getInputProfile(
     return input.profile as StatuslineInputProfile;
 }
 
-export function getInputUsage(input: StatuslineInput | null): StatuslineInputUsage | null {
+export function getInputUsage(
+    input: StatuslineInput | null,
+    type: string | null
+): StatuslineInputUsage | null {
     if (!input) return null;
-    if (isRecord(input.usage)) {
-        return input.usage as StatuslineInputUsage;
+    const normalized = normalizeTypeValue(type);
+    if (normalized === "codex") {
+        return getCodexInputUsage(input);
     }
-    const tokenUsage = input.token_usage;
-    if (tokenUsage !== null && tokenUsage !== undefined) {
-        if (typeof tokenUsage === "number") {
-            return {
-                todayTokens: null,
-                totalTokens: coerceNumber(tokenUsage),
-                inputTokens: null,
-                outputTokens: null,
-            };
-        }
-        if (isRecord(tokenUsage)) {
-            const record = tokenUsage as Record<string, unknown>;
-            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 =
-                firstNumber(
-                    record.outputTokens,
-                    record.output,
-                    record.output_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;
-            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,
-            };
-        }
+    if (normalized === "claude") {
+        return getClaudeInputUsage(input);
     }
-    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) return null;
-    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 {
-            todayTokens: null,
-            totalTokens: null,
-            inputTokens: totalInputTokens,
-            outputTokens: totalOutputTokens,
-        };
-    }
-    const currentUsage = isRecord(contextWindow.current_usage)
-        ? (contextWindow.current_usage as Record<string, unknown>)
-        : isRecord(contextWindow.currentUsage)
-        ? (contextWindow.currentUsage as Record<string, unknown>)
-        : null;
-    if (!currentUsage) return null;
-    const inputTokens =
-        firstNumber(
-            currentUsage.input_tokens,
-            currentUsage.inputTokens
-        ) ?? null;
-    const outputTokens =
-        firstNumber(
-            currentUsage.output_tokens,
-            currentUsage.outputTokens
-        ) ?? null;
-    const cacheRead =
-        firstNumber(
-            currentUsage.cache_read_input_tokens,
-            currentUsage.cacheReadInputTokens
-        ) ?? null;
-    const cacheWrite =
-        firstNumber(
-            currentUsage.cache_creation_input_tokens,
-            currentUsage.cacheCreationInputTokens
-        ) ?? null;
-    if (
-        inputTokens === null &&
-        outputTokens === null &&
-        cacheRead === null &&
-        cacheWrite === null
-    ) {
-        return null;
-    }
-    const totalTokens =
-        (inputTokens || 0) +
-        (outputTokens || 0) +
-        (cacheRead || 0) +
-        (cacheWrite || 0);
-    return {
-        todayTokens: totalTokens,
-        totalTokens: null,
-        inputTokens,
-        outputTokens,
-    };
+    return getCodexInputUsage(input) || getClaudeInputUsage(input);
 }
 
 export function getSessionId(input: StatuslineInput | null): string | null {

package/src/statusline/types.ts

@@ -9,6 +9,8 @@ export interface StatuslineInputUsage {
     totalTokens?: number;
     inputTokens?: number;
     outputTokens?: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
 }
 
 export interface StatuslineInputContextWindowUsage {
@@ -72,11 +74,15 @@ export interface StatuslineUsage {
     totalTokens: number | null;
     inputTokens: number | null;
     outputTokens: number | null;
+    cacheReadTokens: number | null;
+    cacheWriteTokens: number | null;
 }
 
 export interface StatuslineUsageTotals {
     inputTokens: number | null;
     outputTokens: number | null;
+    cacheReadTokens: number | null;
+    cacheWriteTokens: number | null;
     totalTokens: number | null;
 }
 

package/src/statusline/usage/claude.ts

@@ -0,0 +1,299 @@
+import type {
+    StatuslineInput,
+    StatuslineInputUsage,
+    StatuslineUsageTotals,
+} from "../types";
+import { firstNumber, isRecord } from "../utils";
+
+function resolveContextWindow(
+    input: StatuslineInput
+): Record<string, unknown> | null {
+    if (isRecord(input.context_window)) {
+        return input.context_window as Record<string, unknown>;
+    }
+    if (isRecord(input.contextWindow)) {
+        return input.contextWindow as Record<string, unknown>;
+    }
+    return null;
+}
+
+function resolveCurrentUsage(
+    contextWindow: Record<string, unknown>
+): Record<string, unknown> | null {
+    if (isRecord(contextWindow.current_usage)) {
+        return contextWindow.current_usage as Record<string, unknown>;
+    }
+    if (isRecord(contextWindow.currentUsage)) {
+        return contextWindow.currentUsage as Record<string, unknown>;
+    }
+    return null;
+}
+
+function parseClaudeUsageTotalsRecord(
+    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 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;
+    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 parseClaudeInputUsageRecord(
+    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 =
+        firstNumber(
+            record.outputTokens,
+            record.output,
+            record.output_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;
+    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 parseTotalsFromContextWindow(
+    contextWindow: Record<string, unknown>
+): StatuslineUsageTotals | null {
+    const inputTokens =
+        firstNumber(
+            contextWindow.total_input_tokens,
+            contextWindow.totalInputTokens
+        ) ?? null;
+    const outputTokens =
+        firstNumber(
+            contextWindow.total_output_tokens,
+            contextWindow.totalOutputTokens
+        ) ?? null;
+    if (inputTokens === null && outputTokens === null) return null;
+    const currentUsage = resolveCurrentUsage(contextWindow);
+    const cacheRead =
+        currentUsage
+            ? firstNumber(
+                  currentUsage.cache_read_input_tokens,
+                  currentUsage.cacheReadInputTokens
+              ) ?? null
+            : null;
+    const cacheWrite =
+        currentUsage
+            ? firstNumber(
+                  currentUsage.cache_creation_input_tokens,
+                  currentUsage.cacheCreationInputTokens
+              ) ?? null
+            : null;
+    const totalTokens =
+        (inputTokens || 0) +
+        (outputTokens || 0) +
+        (cacheRead || 0) +
+        (cacheWrite || 0);
+    return {
+        inputTokens,
+        outputTokens,
+        cacheReadTokens: cacheRead,
+        cacheWriteTokens: cacheWrite,
+        totalTokens,
+    };
+}
+
+export function getClaudeUsageTotalsFromInput(
+    input: StatuslineInput | null
+): StatuslineUsageTotals | null {
+    if (!input) return null;
+    const contextWindow = resolveContextWindow(input);
+    if (contextWindow) {
+        const totals = parseTotalsFromContextWindow(contextWindow);
+        if (totals) return totals;
+    }
+    if (isRecord(input.usage)) {
+        return parseClaudeUsageTotalsRecord(input.usage as Record<string, unknown>);
+    }
+    return null;
+}
+
+export function getClaudeInputUsage(
+    input: StatuslineInput | null
+): StatuslineInputUsage | null {
+    if (!input) return null;
+    if (isRecord(input.usage)) {
+        const parsed = parseClaudeInputUsageRecord(input.usage as Record<string, unknown>);
+        if (parsed) return parsed;
+        return input.usage as StatuslineInputUsage;
+    }
+    const contextWindow = resolveContextWindow(input);
+    if (!contextWindow) return null;
+    const totals = parseTotalsFromContextWindow(contextWindow);
+    if (totals) {
+        return {
+            todayTokens: null,
+            totalTokens: null,
+            inputTokens: totals.inputTokens,
+            outputTokens: totals.outputTokens,
+            cacheReadTokens: totals.cacheReadTokens,
+            cacheWriteTokens: totals.cacheWriteTokens,
+        };
+    }
+    const currentUsage = resolveCurrentUsage(contextWindow);
+    if (!currentUsage) return null;
+    const inputTokens =
+        firstNumber(
+            currentUsage.input_tokens,
+            currentUsage.inputTokens
+        ) ?? null;
+    const outputTokens =
+        firstNumber(
+            currentUsage.output_tokens,
+            currentUsage.outputTokens
+        ) ?? null;
+    const cacheRead =
+        firstNumber(
+            currentUsage.cache_read_input_tokens,
+            currentUsage.cacheReadInputTokens
+        ) ?? null;
+    const cacheWrite =
+        firstNumber(
+            currentUsage.cache_creation_input_tokens,
+            currentUsage.cacheCreationInputTokens
+        ) ?? null;
+    if (
+        inputTokens === null &&
+        outputTokens === null &&
+        cacheRead === null &&
+        cacheWrite === null
+    ) {
+        return null;
+    }
+    const totalTokens =
+        (inputTokens || 0) +
+        (outputTokens || 0) +
+        (cacheRead || 0) +
+        (cacheWrite || 0);
+    return {
+        todayTokens: totalTokens,
+        totalTokens: null,
+        inputTokens,
+        outputTokens,
+        cacheReadTokens: cacheRead,
+        cacheWriteTokens: cacheWrite,
+    };
+}