@praeviso/code-env-switch 0.1.4 → 0.1.6

package/bin/usage/pricing.js

@@ -0,0 +1,303 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MODEL_PRICING = void 0;
+exports.resolvePricingForProfile = resolvePricingForProfile;
+exports.calculateUsageCost = calculateUsageCost;
+exports.formatUsdAmount = formatUsdAmount;
+const TOKENS_PER_MILLION = 1000000;
+exports.DEFAULT_MODEL_PRICING = {
+    "Claude Sonnet 4.5": {
+        input: 3.0,
+        output: 15.0,
+        cacheWrite: 3.75,
+        cacheRead: 0.3,
+        description: "Balanced performance and speed for daily use.",
+    },
+    "Sonnet 4.5": {
+        input: 3.0,
+        output: 15.0,
+        cacheWrite: 3.75,
+        cacheRead: 0.3,
+        description: "Balanced performance and speed for daily use.",
+    },
+    "Claude Opus 4.5": {
+        input: 5.0,
+        output: 25.0,
+        cacheWrite: 6.25,
+        cacheRead: 0.5,
+        description: "Most capable model for agents and coding.",
+    },
+    "Opus 4.5": {
+        input: 5.0,
+        output: 25.0,
+        cacheWrite: 6.25,
+        cacheRead: 0.5,
+        description: "Most capable model for agents and coding.",
+    },
+    "Claude Haiku 4.5": {
+        input: 1.0,
+        output: 5.0,
+        cacheWrite: 1.25,
+        cacheRead: 0.1,
+        description: "Fast responses for lightweight tasks.",
+    },
+    "Haiku 4.5": {
+        input: 1.0,
+        output: 5.0,
+        cacheWrite: 1.25,
+        cacheRead: 0.1,
+        description: "Fast responses for lightweight tasks.",
+    },
+    "claude-opus-4-5-20251101": {
+        input: 5.0,
+        output: 25.0,
+        cacheWrite: 6.25,
+        cacheRead: 0.5,
+        description: "Most capable model for agents and coding.",
+    },
+    "claude-sonnet-4-5-20251022": {
+        input: 3.0,
+        output: 15.0,
+        cacheWrite: 3.75,
+        cacheRead: 0.3,
+        description: "Balanced performance and speed for daily use.",
+    },
+    "claude-haiku-4-5-20251022": {
+        input: 1.0,
+        output: 5.0,
+        cacheWrite: 1.25,
+        cacheRead: 0.1,
+        description: "Fast responses for lightweight tasks.",
+    },
+    "gpt-5.1": {
+        input: 1.25,
+        output: 10.0,
+        cacheRead: 0.125,
+        description: "Base model for daily development work.",
+    },
+    "gpt-5.1-codex": {
+        input: 1.25,
+        output: 10.0,
+        cacheRead: 0.125,
+        description: "Code-focused model for programming workflows.",
+    },
+    "gpt-5.1-codex-max": {
+        input: 1.25,
+        output: 10.0,
+        cacheRead: 0.125,
+        description: "Flagship code model for complex projects.",
+    },
+    "gpt-5.2": {
+        input: 1.75,
+        output: 14.0,
+        cacheRead: 0.175,
+        description: "Latest flagship model with improved performance.",
+    },
+    "gpt-5.2-codex": {
+        input: 1.75,
+        output: 14.0,
+        cacheRead: 0.175,
+        description: "Latest flagship code model.",
+    },
+};
+function normalizeModelKey(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+function parsePriceValue(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string") {
+        const match = value.replace(/,/g, "").match(/-?\d+(?:\.\d+)?/);
+        if (match) {
+            const parsed = Number(match[0]);
+            return Number.isFinite(parsed) ? parsed : null;
+        }
+    }
+    return null;
+}
+function compactPricing(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const input = parsePriceValue(value.input);
+    const output = parsePriceValue(value.output);
+    const cacheRead = parsePriceValue(value.cacheRead);
+    const cacheWrite = parsePriceValue(value.cacheWrite);
+    const description = typeof value.description === "string" && value.description.trim()
+        ? value.description.trim()
+        : undefined;
+    const pricing = {};
+    let hasNumber = false;
+    if (input !== null) {
+        pricing.input = input;
+        hasNumber = true;
+    }
+    if (output !== null) {
+        pricing.output = output;
+        hasNumber = true;
+    }
+    if (cacheRead !== null) {
+        pricing.cacheRead = cacheRead;
+        hasNumber = true;
+    }
+    if (cacheWrite !== null) {
+        pricing.cacheWrite = cacheWrite;
+        hasNumber = true;
+    }
+    if (description)
+        pricing.description = description;
+    return hasNumber ? pricing : null;
+}
+function resolveMultiplier(value) {
+    const parsed = parsePriceValue(value);
+    if (parsed === null)
+        return null;
+    if (parsed < 0)
+        return null;
+    return parsed;
+}
+function applyMultiplier(pricing, multiplier) {
+    if (!pricing)
+        return null;
+    if (multiplier === null)
+        return pricing;
+    const scaled = {};
+    if (pricing.input !== undefined)
+        scaled.input = pricing.input * multiplier;
+    if (pricing.output !== undefined)
+        scaled.output = pricing.output * multiplier;
+    if (pricing.cacheRead !== undefined)
+        scaled.cacheRead = pricing.cacheRead * multiplier;
+    if (pricing.cacheWrite !== undefined)
+        scaled.cacheWrite = pricing.cacheWrite * multiplier;
+    if (pricing.description)
+        scaled.description = pricing.description;
+    return scaled;
+}
+function buildModelIndex(models) {
+    const index = new Map();
+    if (!models)
+        return index;
+    for (const [model, pricing] of Object.entries(models)) {
+        const key = normalizeModelKey(model);
+        if (!key)
+            continue;
+        const cleaned = compactPricing(pricing);
+        if (!cleaned)
+            continue;
+        index.set(key, { model, pricing: cleaned });
+    }
+    return index;
+}
+function resolveModelPricing(config, model) {
+    var _a;
+    if (!model)
+        return null;
+    const key = normalizeModelKey(model);
+    if (!key)
+        return null;
+    const configIndex = buildModelIndex((_a = config.pricing) === null || _a === void 0 ? void 0 : _a.models);
+    const fromConfig = configIndex.get(key);
+    if (fromConfig)
+        return fromConfig;
+    const defaultsIndex = buildModelIndex(exports.DEFAULT_MODEL_PRICING);
+    return defaultsIndex.get(key) || null;
+}
+function mergePricing(base, override) {
+    if (!base && !override)
+        return null;
+    return compactPricing({ ...(base || {}), ...(override || {}) });
+}
+function getProfilePricing(profile) {
+    var _a;
+    if (!profile || !profile.pricing || typeof profile.pricing !== "object") {
+        return { model: null, pricing: null, multiplier: null };
+    }
+    const raw = profile.pricing;
+    const model = typeof raw.model === "string" && raw.model.trim() ? raw.model.trim() : null;
+    return {
+        model,
+        pricing: compactPricing(raw),
+        multiplier: (_a = raw.multiplier) !== null && _a !== void 0 ? _a : null,
+    };
+}
+function resolvePricingForProfile(config, profile, model) {
+    var _a, _b;
+    const profilePricing = getProfilePricing(profile);
+    const baseFromProfileModel = profilePricing.model
+        ? resolveModelPricing(config, profilePricing.model)
+        : null;
+    const mergedProfile = mergePricing(baseFromProfileModel ? baseFromProfileModel.pricing : null, profilePricing.pricing);
+    const resolvedPricing = mergedProfile ||
+        (baseFromProfileModel ? baseFromProfileModel.pricing : null) ||
+        ((_b = (_a = resolveModelPricing(config, model)) === null || _a === void 0 ? void 0 : _a.pricing) !== null && _b !== void 0 ? _b : null);
+    if (!resolvedPricing)
+        return null;
+    const multiplier = resolveMultiplier(profilePricing.multiplier);
+    return applyMultiplier(resolvedPricing, multiplier);
+}
+function toFiniteNumber(value) {
+    if (value === null || value === undefined)
+        return null;
+    const num = Number(value);
+    if (!Number.isFinite(num))
+        return null;
+    return num;
+}
+function calculateUsageCost(usage, pricing) {
+    var _a, _b, _c, _d, _e, _f;
+    if (!usage || !pricing)
+        return null;
+    const inputTokens = toFiniteNumber(usage.inputTokens);
+    const outputTokens = toFiniteNumber(usage.outputTokens);
+    const cacheReadTokens = toFiniteNumber(usage.cacheReadTokens);
+    const cacheWriteTokens = toFiniteNumber(usage.cacheWriteTokens);
+    if (inputTokens === null &&
+        outputTokens === null &&
+        cacheReadTokens === null &&
+        cacheWriteTokens === null) {
+        return null;
+    }
+    const tokens = {
+        input: Math.max(0, inputTokens || 0),
+        output: Math.max(0, outputTokens || 0),
+        cacheRead: Math.max(0, cacheReadTokens || 0),
+        cacheWrite: Math.max(0, cacheWriteTokens || 0),
+    };
+    const knownTotal = toFiniteNumber((_b = (_a = usage.todayTokens) !== null && _a !== void 0 ? _a : usage.totalTokens) !== null && _b !== void 0 ? _b : null);
+    const breakdownTotal = tokens.input + tokens.output + tokens.cacheRead + tokens.cacheWrite;
+    if (breakdownTotal === 0 && knownTotal !== null && knownTotal > 0) {
+        return null;
+    }
+    if (tokens.input > 0 && pricing.input === undefined)
+        return null;
+    if (tokens.output > 0 && pricing.output === undefined)
+        return null;
+    if (tokens.cacheRead > 0 && pricing.cacheRead === undefined)
+        return null;
+    if (tokens.cacheWrite > 0 && pricing.cacheWrite === undefined)
+        return null;
+    const total = (tokens.input * ((_c = pricing.input) !== null && _c !== void 0 ? _c : 0) +
+        tokens.output * ((_d = pricing.output) !== null && _d !== void 0 ? _d : 0) +
+        tokens.cacheRead * ((_e = pricing.cacheRead) !== null && _e !== void 0 ? _e : 0) +
+        tokens.cacheWrite * ((_f = pricing.cacheWrite) !== null && _f !== void 0 ? _f : 0)) /
+        TOKENS_PER_MILLION;
+    return Number.isFinite(total) ? total : null;
+}
+function formatUsdAmount(amount) {
+    if (amount === null || !Number.isFinite(amount))
+        return "-";
+    const normalized = Math.abs(amount) < 1e-12 ? 0 : amount;
+    const abs = Math.abs(normalized);
+    let decimals = 2;
+    if (abs < 1)
+        decimals = 4;
+    if (abs < 0.1)
+        decimals = 5;
+    if (abs < 0.01)
+        decimals = 6;
+    let text = normalized.toFixed(decimals);
+    text = text.replace(/\.?0+$/, "");
+    return `$${text}`;
+}

package/code-env.example.json

@@ -15,6 +15,61 @@
     "type": "command",
     "padding": 0
   },
+  "pricing": {
+    "models": {
+      "Claude Sonnet 4.5": {
+        "input": 3.0,
+        "output": 15.0,
+        "cacheWrite": 3.75,
+        "cacheRead": 0.3,
+        "description": "Balanced performance and speed for daily use."
+      },
+      "Claude Opus 4.5": {
+        "input": 5.0,
+        "output": 25.0,
+        "cacheWrite": 6.25,
+        "cacheRead": 0.5,
+        "description": "Most capable model for agents and coding."
+      },
+      "Claude Haiku 4.5": {
+        "input": 1.0,
+        "output": 5.0,
+        "cacheWrite": 1.25,
+        "cacheRead": 0.1,
+        "description": "Fast responses for lightweight tasks."
+      },
+      "gpt-5.1": {
+        "input": 1.25,
+        "output": 10.0,
+        "cacheRead": 0.125,
+        "description": "Base model for daily development work."
+      },
+      "gpt-5.1-codex": {
+        "input": 1.25,
+        "output": 10.0,
+        "cacheRead": 0.125,
+        "description": "Code-focused model for programming workflows."
+      },
+      "gpt-5.1-codex-max": {
+        "input": 1.25,
+        "output": 10.0,
+        "cacheRead": 0.125,
+        "description": "Flagship code model for complex projects."
+      },
+      "gpt-5.2": {
+        "input": 1.75,
+        "output": 14.0,
+        "cacheRead": 0.175,
+        "description": "Latest flagship model with improved performance."
+      },
+      "gpt-5.2-codex": {
+        "input": 1.75,
+        "output": 14.0,
+        "cacheRead": 0.175,
+        "description": "Latest flagship code model."
+      }
+    }
+  },
   "profiles": {
     "p_a1b2c3": {
       "name": "primary",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@praeviso/code-env-switch",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Switch between Claude Code and Codex environment variables from a single CLI",
   "bin": {
     "codenv": "bin/index.js"

package/src/cli/args.ts

@@ -5,6 +5,7 @@ import type {
     ParsedArgs,
     InitArgs,
     AddArgs,
+    UsageResetArgs,
     ProfileType,
     StatuslineArgs,
 } from "../types";
@@ -156,6 +157,19 @@ export function parseAddArgs(args: string[]): AddArgs {
     return result;
 }
 
+export function parseUsageResetArgs(args: string[]): UsageResetArgs {
+    const result: UsageResetArgs = { yes: false };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "-y" || arg === "--yes") {
+            result.yes = true;
+            continue;
+        }
+        throw new Error(`Unknown usage-reset argument: ${arg}`);
+    }
+    return result;
+}
+
 function parseNumberFlag(value: string | null | undefined, flag: string): number {
     if (value === null || value === undefined || value === "") {
         throw new Error(`Missing value for ${flag}.`);

package/src/cli/help.ts

@@ -27,6 +27,7 @@ Usage:
   codenv launch <codex|claude> [--] [args...]
   codenv init
   codenv statusline [options]
+  codenv usage-reset [--yes]
 
 Options:
   -c, --config <path>   Path to config JSON
@@ -57,6 +58,9 @@ Statusline options:
   --usage-output <n>          Set output token usage
   --sync-usage                Sync usage from sessions before reading
 
+Usage reset options:
+  -y, --yes                   Skip confirmation prompt
+
 Examples:
   codenv init
   codenv use codex primary
@@ -67,6 +71,7 @@ Examples:
   codenv remove --all
   codenv launch codex -- --help
   codenv statusline --format json
+  codenv usage-reset --yes
   CODE_ENV_CONFIG=~/.config/code-env/config.json codenv use claude default
   codenv add --type codex primary OPENAI_BASE_URL=https://api.example.com/v1 OPENAI_API_KEY=YOUR_API_KEY
   codenv add

package/src/cli/index.ts

@@ -1,5 +1,11 @@
 /**
  * CLI module exports
  */
-export { parseArgs, parseInitArgs, parseAddArgs, parseStatuslineArgs } from "./args";
+export {
+    parseArgs,
+    parseInitArgs,
+    parseAddArgs,
+    parseUsageResetArgs,
+    parseStatuslineArgs,
+} from "./args";
 export { printHelp } from "./help";

package/src/commands/index.ts

@@ -8,3 +8,4 @@ export { printShow } from "./show";
 export { printUnset } from "./unset";
 export { runLaunch } from "./launch";
 export { printStatusline } from "./statusline";
+export { runUsageReset } from "./usage";

package/src/commands/list.ts

@@ -6,9 +6,12 @@ import { buildListRows } from "../profile/display";
 import { getResolvedDefaultProfileKeys } from "../config/defaults";
 import {
     formatTokenCount,
+    readUsageCostIndex,
     readUsageTotalsIndex,
+    resolveUsageCostForProfile,
     resolveUsageTotalsForProfile,
 } from "../usage";
+import { formatUsdAmount } from "../usage/pricing";
 
 export function printList(config: Config, configPath: string | null): void {
     const rows = buildListRows(config, getResolvedDefaultProfileKeys);
@@ -18,6 +21,7 @@ export function printList(config: Config, configPath: string | null): void {
     }
     try {
         const usageTotals = readUsageTotalsIndex(config, configPath, true);
+        const usageCosts = readUsageCostIndex(config, configPath, false);
         if (usageTotals) {
             for (const row of rows) {
                 if (!row.usageType) continue;
@@ -32,6 +36,22 @@ export function printList(config: Config, configPath: string | null): void {
                 row.totalTokens = usage.total;
             }
         }
+        if (usageCosts) {
+            for (const row of rows) {
+                if (!row.usageType) continue;
+                const cost = resolveUsageCostForProfile(
+                    usageCosts,
+                    row.usageType,
+                    row.key,
+                    row.name
+                );
+                if (!cost) continue;
+                row.todayCost = cost.today;
+                row.totalCost = cost.total;
+                row.todayBilledTokens = cost.todayTokens;
+                row.totalBilledTokens = cost.totalTokens;
+            }
+        }
     } catch {
         // ignore usage sync errors
     }
@@ -40,8 +60,20 @@ export function printList(config: Config, configPath: string | null): void {
     const headerToday = "TODAY";
     const headerTotal = "TOTAL";
     const headerNote = "NOTE";
-    const todayTexts = rows.map((row) => formatTokenCount(row.todayTokens));
-    const totalTexts = rows.map((row) => formatTokenCount(row.totalTokens));
+    const todayTexts = rows.map((row) =>
+        formatUsageWithCost(
+            row.todayTokens,
+            row.todayBilledTokens ?? null,
+            row.todayCost ?? null
+        )
+    );
+    const totalTexts = rows.map((row) =>
+        formatUsageWithCost(
+            row.totalTokens,
+            row.totalBilledTokens ?? null,
+            row.totalCost ?? null
+        )
+    );
     const nameWidth = Math.max(
         headerName.length,
         ...rows.map((row) => row.name.length)
@@ -67,7 +99,15 @@ export function printList(config: Config, configPath: string | null): void {
             todayWidth
         )}  ${total.padStart(totalWidth)}  ${note.padEnd(noteWidth)}`;
 
-    console.log(formatRow(headerName, headerType, headerToday, headerTotal, headerNote));
+    console.log(
+        formatRow(
+            headerName,
+            headerType,
+            headerToday,
+            headerTotal,
+            headerNote
+        )
+    );
     console.log(
         formatRow(
             "-".repeat(nameWidth),
@@ -81,7 +121,13 @@ export function printList(config: Config, configPath: string | null): void {
         const row = rows[i];
         const todayText = todayTexts[i] || "-";
         const totalText = totalTexts[i] || "-";
-        const line = formatRow(row.name, row.type, todayText, totalText, row.note);
+        const line = formatRow(
+            row.name,
+            row.type,
+            todayText,
+            totalText,
+            row.note
+        );
         if (row.active) {
             console.log(`\x1b[32m${line}\x1b[0m`);
         } else {
@@ -89,3 +135,27 @@ export function printList(config: Config, configPath: string | null): void {
         }
     }
 }
+
+function formatUsageWithCost(
+    tokens: number | null | undefined,
+    billedTokens: number | null,
+    cost: number | null
+): string {
+    const tokenText = formatTokenCount(tokens ?? null);
+    if (tokenText === "-") return tokenText;
+    if (cost === null || !Number.isFinite(cost)) return tokenText;
+    if (tokens === null || tokens === undefined || !Number.isFinite(tokens)) {
+        return tokenText;
+    }
+    if (billedTokens === null || !Number.isFinite(billedTokens)) {
+        return `${tokenText} (${formatUsdAmount(cost)})`;
+    }
+    if (billedTokens >= tokens) {
+        return `${tokenText} (${formatUsdAmount(cost)})`;
+    }
+    const billedText = formatTokenCount(billedTokens);
+    if (billedText === "-") {
+        return `${tokenText} (${formatUsdAmount(cost)})`;
+    }
+    return `${tokenText} (billed ${billedText}, ${formatUsdAmount(cost)})`;
+}

package/src/commands/usage.ts

@@ -0,0 +1,53 @@
+/**
+ * Usage history reset command
+ */
+import type { Config, UsageResetArgs } from "../types";
+import { clearUsageHistory } from "../usage";
+import { askConfirm, createReadline } from "../ui";
+
+export async function runUsageReset(
+    config: Config,
+    configPath: string | null,
+    args: UsageResetArgs
+): Promise<void> {
+    if (!args.yes) {
+        const rl = createReadline();
+        try {
+            const confirmed = await askConfirm(
+                rl,
+                "Clear all usage history files? This cannot be undone. (y/N): "
+            );
+            if (!confirmed) return;
+        } finally {
+            rl.close();
+        }
+    }
+
+    const result = clearUsageHistory(config, configPath);
+    const removed = result.removed.sort();
+    const missing = result.missing.sort();
+    const failed = result.failed.sort((a, b) => a.path.localeCompare(b.path));
+
+    if (removed.length === 0 && failed.length === 0) {
+        console.log("No usage files found.");
+        return;
+    }
+
+    if (removed.length > 0) {
+        console.log(`Removed ${removed.length} file(s):`);
+        for (const filePath of removed) {
+            console.log(`- ${filePath}`);
+        }
+    }
+
+    if (missing.length > 0) {
+        console.log(`Skipped ${missing.length} missing file(s).`);
+    }
+
+    if (failed.length > 0) {
+        for (const failure of failed) {
+            console.error(`Failed to remove ${failure.path}: ${failure.error}`);
+        }
+        process.exitCode = 1;
+    }
+}

package/src/index.ts

@@ -10,6 +10,7 @@ import {
     parseArgs,
     parseInitArgs,
     parseAddArgs,
+    parseUsageResetArgs,
     parseStatuslineArgs,
     printHelp,
 } from "./cli";
@@ -33,6 +34,7 @@ import {
     printUnset,
     runLaunch,
     printStatusline,
+    runUsageReset,
 } from "./commands";
 import { logProfileUse } from "./usage";
 import { createReadline, askConfirm, runInteractiveAdd, runInteractiveUse } from "./ui";
@@ -152,6 +154,15 @@ async function main() {
             return;
         }
 
+        if (cmd === "usage-reset" || cmd === "reset-usage") {
+            const resetArgs = parseUsageResetArgs(args.slice(1));
+            const configPath =
+                process.env.CODE_ENV_CONFIG_PATH || findConfigPath(parsed.configPath);
+            const config = readConfigIfExists(configPath);
+            await runUsageReset(config, configPath, resetArgs);
+            return;
+        }
+
         const configPath = findConfigPath(parsed.configPath);
         const config = readConfig(configPath!);
 

package/src/statusline/debug.ts

@@ -16,7 +16,7 @@ function resolveDefaultConfigDir(configPath: string | null): string {
     return path.join(os.homedir(), ".config", "code-env");
 }
 
-function getStatuslineDebugPath(configPath: string | null): string {
+export function getStatuslineDebugPath(configPath: string | null): string {
     const envPath = resolvePath(process.env.CODE_ENV_STATUSLINE_DEBUG_PATH);
     if (envPath) return envPath;
     return path.join(resolveDefaultConfigDir(configPath), "statusline-debug.jsonl");