@praeviso/code-env-switch 0.1.3 → 0.1.4

package/src/statusline/input.ts

@@ -0,0 +1,300 @@
+import * as fs from "fs";
+import { DEFAULT_PROFILE_TYPES } from "../constants";
+import { normalizeType } from "../profile/type";
+import type {
+    GitStatus,
+    StatuslineInput,
+    StatuslineInputProfile,
+    StatuslineInputUsage,
+} from "./types";
+import { coerceNumber, firstNonEmpty, firstNumber, isRecord } from "./utils";
+
+export function readStdinJson(): StatuslineInput | null {
+    if (process.stdin.isTTY) return null;
+    try {
+        const raw = fs.readFileSync(0, "utf8");
+        const trimmed = raw.trim();
+        if (!trimmed) return null;
+        const parsed = JSON.parse(trimmed);
+        if (!isRecord(parsed)) return null;
+        return parsed as StatuslineInput;
+    } catch {
+        return null;
+    }
+}
+
+export function normalizeTypeValue(value: string | null): string | null {
+    if (!value) return null;
+    const normalized = normalizeType(value);
+    if (normalized) return normalized;
+    const trimmed = String(value).trim();
+    return trimmed ? trimmed : null;
+}
+
+export function detectTypeFromEnv(): string | null {
+    const matches = DEFAULT_PROFILE_TYPES.filter((type) => {
+        const suffix = type.toUpperCase();
+        return (
+            process.env[`CODE_ENV_PROFILE_KEY_${suffix}`] ||
+            process.env[`CODE_ENV_PROFILE_NAME_${suffix}`]
+        );
+    });
+    if (matches.length === 1) return matches[0];
+    return null;
+}
+
+export function resolveEnvProfile(
+    type: string | null
+): { key: string | null; name: string | null } {
+    const genericKey = process.env.CODE_ENV_PROFILE_KEY || null;
+    const genericName = process.env.CODE_ENV_PROFILE_NAME || null;
+    if (!type) {
+        return { key: genericKey, name: genericName };
+    }
+    const suffix = type.toUpperCase();
+    const key = process.env[`CODE_ENV_PROFILE_KEY_${suffix}`] || genericKey;
+    const name = process.env[`CODE_ENV_PROFILE_NAME_${suffix}`] || genericName;
+    return { key: key || null, name: name || null };
+}
+
+export function getModelFromInput(input: StatuslineInput | null): string | null {
+    if (!input) return null;
+    const raw = input.model;
+    if (!raw) return null;
+    if (typeof raw === "string") return raw;
+    if (isRecord(raw)) {
+        const displayName = raw.displayName || raw.display_name;
+        if (displayName) return String(displayName);
+        if (raw.id) return String(raw.id);
+    }
+    return null;
+}
+
+export function getModelProviderFromInput(input: StatuslineInput | null): string | null {
+    if (!input || !input.model_provider) return null;
+    const provider = String(input.model_provider).trim();
+    return provider ? provider : null;
+}
+
+export function getInputProfile(
+    input: StatuslineInput | null
+): StatuslineInputProfile | null {
+    if (!input || !isRecord(input.profile)) return null;
+    return input.profile as StatuslineInputProfile;
+}
+
+export function getInputUsage(input: StatuslineInput | null): StatuslineInputUsage | null {
+    if (!input) return null;
+    if (isRecord(input.usage)) {
+        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,
+            };
+        }
+        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,
+            };
+        }
+    }
+    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,
+    };
+}
+
+export function getSessionId(input: StatuslineInput | null): string | null {
+    if (!input) return null;
+    return firstNonEmpty(input.session_id, input.sessionId);
+}
+
+export function getContextUsedTokens(input: StatuslineInput | null): number | null {
+    if (!input) return null;
+    return coerceNumber(input.context_window_used_tokens);
+}
+
+export function getContextLeftPercent(
+    input: StatuslineInput | null,
+    type: string | null
+): number | null {
+    if (!input) return null;
+    const raw = coerceNumber(input.context_window_percent);
+    if (raw === null || raw < 0) return null;
+    const percent = raw <= 1 ? raw * 100 : raw;
+    if (percent > 100) return null;
+    const usedTokens = getContextUsedTokens(input);
+    const normalizedType = normalizeTypeValue(type);
+    const preferRemaining =
+        normalizedType === "codex" ||
+        normalizedType === "claude" ||
+        usedTokens === null ||
+        (usedTokens <= 0 && percent >= 99);
+    const left = preferRemaining ? percent : 100 - percent;
+    return Math.max(0, Math.min(100, left));
+}
+
+export function getWorkspaceDir(input: StatuslineInput | null): string | null {
+    if (!input || !isRecord(input.workspace)) return null;
+    const currentDir = input.workspace.current_dir;
+    if (currentDir) {
+        const trimmed = String(currentDir).trim();
+        if (trimmed) return trimmed;
+    }
+    const projectDir = input.workspace.project_dir;
+    if (!projectDir) return null;
+    const trimmed = String(projectDir).trim();
+    return trimmed ? trimmed : null;
+}
+
+export function getGitStatusFromInput(input: StatuslineInput | null): GitStatus | null {
+    if (!input || !input.git_branch) return null;
+    const branch = String(input.git_branch).trim();
+    if (!branch) return null;
+    return {
+        branch,
+        ahead: 0,
+        behind: 0,
+        staged: 0,
+        unstaged: 0,
+        untracked: 0,
+        conflicted: 0,
+    };
+}

package/src/statusline/style.ts

@@ -0,0 +1,19 @@
+const COLOR_ENABLED = !process.env.NO_COLOR && process.env.TERM !== "dumb";
+const ANSI_RESET = "\x1b[0m";
+
+export const ICON_GIT = "⎇";
+export const ICON_PROFILE = "👤";
+export const ICON_MODEL = "⚙";
+export const ICON_USAGE = "⚡";
+export const ICON_CONTEXT = "🧠";
+export const ICON_REVIEW = "📝";
+export const ICON_CWD = "📁";
+
+export function colorize(text: string, colorCode: string): string {
+    if (!COLOR_ENABLED) return text;
+    return `\x1b[${colorCode}m${text}${ANSI_RESET}`;
+}
+
+export function dim(text: string): string {
+    return colorize(text, "2");
+}

package/src/statusline/types.ts

@@ -0,0 +1,105 @@
+export interface StatuslineInputProfile {
+    key?: string;
+    name?: string;
+    type?: string;
+}
+
+export interface StatuslineInputUsage {
+    todayTokens?: number;
+    totalTokens?: number;
+    inputTokens?: number;
+    outputTokens?: number;
+}
+
+export interface StatuslineInputContextWindowUsage {
+    input_tokens?: number;
+    output_tokens?: number;
+    cache_creation_input_tokens?: number;
+    cache_read_input_tokens?: number;
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheCreationInputTokens?: number;
+    cacheReadInputTokens?: number;
+}
+
+export interface StatuslineInputContextWindow {
+    current_usage?: StatuslineInputContextWindowUsage | null;
+    total_input_tokens?: number;
+    total_output_tokens?: number;
+    context_window_size?: number;
+    currentUsage?: StatuslineInputContextWindowUsage | null;
+    totalInputTokens?: number;
+    totalOutputTokens?: number;
+    contextWindowSize?: number;
+}
+
+export interface StatuslineInputModel {
+    id?: string;
+    displayName?: string;
+    display_name?: string;
+}
+
+export interface StatuslineInput {
+    cwd?: string;
+    type?: string;
+    profile?: StatuslineInputProfile;
+    model?: string | StatuslineInputModel;
+    model_provider?: string;
+    usage?: StatuslineInputUsage;
+    token_usage?: StatuslineInputUsage | number | Record<string, unknown>;
+    git_branch?: string;
+    task_running?: boolean;
+    review_mode?: boolean;
+    context_window_percent?: number;
+    context_window_used_tokens?: number;
+    context_window?: StatuslineInputContextWindow | Record<string, unknown> | null;
+    contextWindow?: StatuslineInputContextWindow | Record<string, unknown> | null;
+    workspace?: {
+        current_dir?: string;
+        project_dir?: string;
+    };
+    cost?: Record<string, unknown>;
+    version?: string;
+    output_style?: { name?: string };
+    session_id?: string;
+    sessionId?: string;
+    transcript_path?: string;
+    hook_event_name?: string;
+}
+
+export interface StatuslineUsage {
+    todayTokens: number | null;
+    totalTokens: number | null;
+    inputTokens: number | null;
+    outputTokens: number | null;
+}
+
+export interface StatuslineUsageTotals {
+    inputTokens: number | null;
+    outputTokens: number | null;
+    totalTokens: number | null;
+}
+
+export interface GitStatus {
+    branch: string | null;
+    ahead: number;
+    behind: number;
+    staged: number;
+    unstaged: number;
+    untracked: number;
+    conflicted: number;
+}
+
+export interface StatuslineJson {
+    cwd: string;
+    type: string | null;
+    profile: { key: string | null; name: string | null };
+    model: string | null;
+    usage: StatuslineUsage | null;
+    git: GitStatus | null;
+}
+
+export interface StatuslineResult {
+    text: string;
+    json: StatuslineJson;
+}

package/src/statusline/usage.ts

@@ -0,0 +1,175 @@
+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,
+    };
+}
+
+export function getUsageTotalsFromInput(
+    input: StatuslineInput | 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);
+    }
+    if (isRecord(input.usage)) {
+        return parseUsageTotalsRecord(input.usage as Record<string, unknown>);
+    }
+    return null;
+}
+
+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),
+    };
+    const hasUsage =
+        usage.todayTokens !== null ||
+        usage.totalTokens !== null ||
+        usage.inputTokens !== null ||
+        usage.outputTokens !== 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: null,
+            outputTokens: 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;
+}