@praeviso/code-env-switch 0.1.3 → 0.1.5

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.3",
+  "version": "0.1.5",
   "description": "Switch between Claude Code and Codex environment variables from a single CLI",
   "bin": {
     "codenv": "bin/index.js"

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/statusline/debug.ts

@@ -0,0 +1,40 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { resolvePath } from "../shell/utils";
+
+function isStatuslineDebugEnabled(): boolean {
+    const raw = process.env.CODE_ENV_STATUSLINE_DEBUG;
+    if (!raw) return false;
+    const value = String(raw).trim().toLowerCase();
+    if (!value) return false;
+    return !["0", "false", "no", "off"].includes(value);
+}
+
+function resolveDefaultConfigDir(configPath: string | null): string {
+    if (configPath) return path.dirname(configPath);
+    return path.join(os.homedir(), ".config", "code-env");
+}
+
+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");
+}
+
+export function appendStatuslineDebug(
+    configPath: string | null,
+    payload: Record<string, unknown>
+) {
+    if (!isStatuslineDebugEnabled()) return;
+    try {
+        const debugPath = getStatuslineDebugPath(configPath);
+        const dir = path.dirname(debugPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.appendFileSync(debugPath, `${JSON.stringify(payload)}\n`, "utf8");
+    } catch {
+        // ignore debug logging failures
+    }
+}

package/src/statusline/format.ts

@@ -0,0 +1,67 @@
+import { formatTokenCount } from "../usage";
+import { formatUsdAmount } from "../usage/pricing";
+import {
+    ICON_CONTEXT,
+    ICON_CWD,
+    ICON_MODEL,
+    ICON_PROFILE,
+    ICON_REVIEW,
+    ICON_USAGE,
+    colorize,
+    dim,
+} from "./style";
+import * as path from "path";
+
+export function getCwdSegment(cwd: string): string | null {
+    if (!cwd) return null;
+    const base = path.basename(cwd) || cwd;
+    const segment = `${ICON_CWD} ${base}`;
+    return dim(segment);
+}
+
+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");
+}
+
+export function formatModelSegment(
+    model: string | null,
+    provider: string | null
+): string | null {
+    if (!model) return null;
+    const providerLabel = provider ? `${provider}:${model}` : model;
+    return colorize(`${ICON_MODEL} ${providerLabel}`, "35");
+}
+
+export function formatProfileSegment(
+    type: string | null,
+    profileKey: string | null,
+    profileName: string | null
+): string | null {
+    const name = profileName || profileKey;
+    if (!name) return null;
+    const label = type ? `${type}:${name}` : name;
+    return colorize(`${ICON_PROFILE} ${label}`, "37");
+}
+
+export function formatContextSegment(contextLeft: number | null): string | null {
+    if (contextLeft === null) return null;
+    const left = Math.max(0, Math.min(100, Math.round(contextLeft)));
+    return colorize(`${ICON_CONTEXT} ${left}% left`, "36");
+}
+
+export function formatContextUsedSegment(usedTokens: number | null): string | null {
+    if (usedTokens === null) return null;
+    return colorize(`${ICON_CONTEXT} ${formatTokenCount(usedTokens)} used`, "36");
+}
+
+export function formatModeSegment(reviewMode: boolean): string | null {
+    if (!reviewMode) return null;
+    return colorize(`${ICON_REVIEW} review`, "34");
+}

package/src/statusline/git.ts

@@ -0,0 +1,82 @@
+import { spawnSync } from "child_process";
+import type { GitStatus } from "./types";
+import { colorize } from "./style";
+import { ICON_GIT } from "./style";
+
+export function getGitStatus(cwd: string): GitStatus | null {
+    if (!cwd) return null;
+    const result = spawnSync("git", ["-C", cwd, "status", "--porcelain=v2", "-b"], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+    });
+    if (result.status !== 0 || !result.stdout) return null;
+    const status: GitStatus = {
+        branch: null,
+        ahead: 0,
+        behind: 0,
+        staged: 0,
+        unstaged: 0,
+        untracked: 0,
+        conflicted: 0,
+    };
+
+    const lines = result.stdout.split(/\r?\n/);
+    for (const line of lines) {
+        if (!line) continue;
+        if (line.startsWith("# branch.head ")) {
+            status.branch = line.slice("# branch.head ".length).trim();
+            continue;
+        }
+        if (line.startsWith("# branch.ab ")) {
+            const parts = line
+                .slice("# branch.ab ".length)
+                .trim()
+                .split(/\s+/);
+            for (const part of parts) {
+                if (part.startsWith("+")) status.ahead = Number(part.slice(1)) || 0;
+                if (part.startsWith("-")) status.behind = Number(part.slice(1)) || 0;
+            }
+            continue;
+        }
+        if (line.startsWith("? ")) {
+            status.untracked += 1;
+            continue;
+        }
+        if (line.startsWith("u ")) {
+            status.conflicted += 1;
+            continue;
+        }
+        if (line.startsWith("1 ") || line.startsWith("2 ")) {
+            const parts = line.split(/\s+/);
+            const xy = parts[1] || "";
+            const staged = xy[0];
+            const unstaged = xy[1];
+            if (staged && staged !== ".") status.staged += 1;
+            if (unstaged && unstaged !== ".") status.unstaged += 1;
+            continue;
+        }
+    }
+
+    if (!status.branch) {
+        status.branch = "HEAD";
+    }
+    return status;
+}
+
+export function formatGitSegment(status: GitStatus | null): string | null {
+    if (!status || !status.branch) return null;
+    const meta: string[] = [];
+    const dirtyCount = status.staged + status.unstaged + status.untracked;
+    if (status.ahead > 0) meta.push(`↑${status.ahead}`);
+    if (status.behind > 0) meta.push(`↓${status.behind}`);
+    if (status.conflicted > 0) meta.push(`✖${status.conflicted}`);
+    if (dirtyCount > 0) meta.push(`+${dirtyCount}`);
+    const suffix = meta.length > 0 ? ` [${meta.join("")}]` : "";
+    const text = `${ICON_GIT} ${status.branch}${suffix}`;
+    const hasConflicts = status.conflicted > 0;
+    const isDirty = dirtyCount > 0;
+    if (hasConflicts) return colorize(text, "31");
+    if (isDirty) return colorize(text, "33");
+    if (status.ahead > 0 || status.behind > 0) return colorize(text, "36");
+    return colorize(text, "32");
+}