coding-usage-bar 0.1.0

package/dist/minimax.d.ts

@@ -0,0 +1,47 @@
+import { MinimaxConfig, ProviderUsage } from "./types.js";
+interface MinimaxModelRemain {
+    model_name: string;
+    start_time: number;
+    end_time: number;
+    remains_time: number;
+    current_interval_total_count: number;
+    current_interval_usage_count: number;
+    current_interval_remaining_percent?: number;
+    current_weekly_total_count: number;
+    current_weekly_usage_count: number;
+    current_weekly_remaining_percent?: number;
+    weekly_start_time: number;
+    weekly_end_time: number;
+    weekly_remains_time: number;
+}
+interface MinimaxQuotaResponse {
+    model_remains: MinimaxModelRemain[];
+    category_remains?: MinimaxCategoryRemain[];
+    base_resp: {
+        status_code: number;
+        status_msg: string;
+    };
+}
+interface MinimaxCategoryRemain {
+    start_time: number;
+    end_time: number;
+    remains_time: number;
+    current_interval_total_count: number;
+    current_interval_usage_count: number;
+    current_interval_remaining_percent?: number;
+    current_weekly_total_count: number;
+    current_weekly_usage_count: number;
+    current_weekly_remaining_percent?: number;
+    weekly_start_time: number;
+    weekly_end_time: number;
+    weekly_remains_time: number;
+    category: string;
+    display_name: string;
+}
+export declare function fetchMinimaxQuota(config: MinimaxConfig): Promise<MinimaxQuotaResponse>;
+export declare function usageFromMinimaxQuota(quota: MinimaxQuotaResponse, options: {
+    observedAt?: string;
+    source: string;
+}): ProviderUsage | null;
+export declare function collectMinimaxUsage(config: MinimaxConfig): Promise<ProviderUsage>;
+export {};

package/dist/minimax.js

@@ -0,0 +1,100 @@
+import { makeProviderUsage, normalizeWindow } from "./usage.js";
+const CN_BASE_URL = "https://api.minimaxi.com";
+const GLOBAL_BASE_URL = "https://api.minimax.io";
+function baseUrl(config) {
+    return config.region === "global" ? GLOBAL_BASE_URL : CN_BASE_URL;
+}
+export async function fetchMinimaxQuota(config) {
+    const url = `${baseUrl(config)}/v1/token_plan/remains`;
+    const response = await fetch(url, {
+        method: "GET",
+        headers: {
+            "Authorization": `Bearer ${config.apiKey}`,
+            "Content-Type": "application/json",
+        },
+        signal: AbortSignal.timeout(15_000),
+    });
+    if (!response.ok) {
+        throw new Error(`MiniMax quota API returned HTTP ${response.status}`);
+    }
+    const data = (await response.json());
+    if (data.base_resp?.status_code !== 0) {
+        throw new Error(`MiniMax API error: ${data.base_resp?.status_msg ?? "unknown error"} (code ${data.base_resp?.status_code})`);
+    }
+    return data;
+}
+export function usageFromMinimaxQuota(quota, options) {
+    const models = quota.model_remains;
+    const categories = quota.category_remains;
+    if (!models || models.length === 0) {
+        return null;
+    }
+    // Prefer the "general" model entry — it reflects the text/chat plan this CLI
+    // is most often used for. Fall back to the first model so we never return
+    // null for an account that only reports other models.
+    const primary = models.find((m) => m.model_name === "general") ?? models[0];
+    let fiveHourPercent = 0;
+    let fiveHourReset = primary.end_time;
+    let weeklyPercent = 0;
+    let weeklyReset = primary.weekly_end_time;
+    if (categories && categories.length > 0) {
+        const textGen = categories.find((c) => c.category === "text_generation");
+        if (textGen) {
+            fiveHourPercent = percentFromQuota(textGen.current_interval_total_count, textGen.current_interval_usage_count, textGen.current_interval_remaining_percent);
+            fiveHourReset = textGen.end_time;
+            weeklyPercent = percentFromQuota(textGen.current_weekly_total_count, textGen.current_weekly_usage_count, textGen.current_weekly_remaining_percent) ?? fiveHourPercent;
+            weeklyReset = textGen.weekly_end_time;
+        }
+    }
+    else {
+        fiveHourPercent = percentFromQuota(primary.current_interval_total_count, primary.current_interval_usage_count, primary.current_interval_remaining_percent);
+        weeklyPercent = percentFromQuota(primary.current_weekly_total_count, primary.current_weekly_usage_count, primary.current_weekly_remaining_percent) ?? fiveHourPercent;
+    }
+    const fiveHour = normalizeWindow("five_hour", {
+        used_percent: fiveHourPercent,
+        resets_at: new Date(fiveHourReset).toISOString(),
+    }, 300);
+    const sevenDay = normalizeWindow("seven_day", {
+        used_percent: weeklyPercent,
+        resets_at: new Date(weeklyReset).toISOString(),
+    }, 10080);
+    if (!fiveHour || !sevenDay) {
+        return null;
+    }
+    return makeProviderUsage({
+        provider: "minimax",
+        source: options.source,
+        observedAt: options.observedAt,
+        planType: primary.model_name ?? null,
+        fiveHour,
+        sevenDay,
+    });
+}
+// MiniMax reports usage two ways depending on plan type. Count-based accounts
+// (e.g. `video`) populate current_*_usage_count / current_*_total_count.
+// Credit-based accounts (e.g. `general`) keep total at 0 and expose
+// current_*_remaining_percent in 0-100. Prefer the count ratio when total > 0,
+// otherwise derive from the remaining percent, and only fall back to 0 when
+// neither signal is present.
+function percentFromQuota(totalCount, usageCount, remainingPercent) {
+    if (typeof totalCount === "number" && totalCount > 0 && typeof usageCount === "number") {
+        return Math.max(0, Math.min(100, (usageCount / totalCount) * 100));
+    }
+    if (typeof remainingPercent === "number" && Number.isFinite(remainingPercent)) {
+        return Math.max(0, Math.min(100, 100 - remainingPercent));
+    }
+    return 0;
+}
+export async function collectMinimaxUsage(config) {
+    if (!config.apiKey) {
+        throw new Error("MiniMax API key not configured. Edit ~/.coding-usage-bar/config.json to set minimax.apiKey.");
+    }
+    const quota = await fetchMinimaxQuota(config);
+    const usage = usageFromMinimaxQuota(quota, {
+        source: `${baseUrl(config)}/v1/token_plan/remains`,
+    });
+    if (!usage) {
+        throw new Error("MiniMax quota response did not contain expected token plan data");
+    }
+    return usage;
+}

package/dist/node-runtime.d.ts

@@ -0,0 +1 @@
+export declare function stableNodeExecutable(): string;

package/dist/node-runtime.js

@@ -0,0 +1,29 @@
+import fs from "node:fs";
+import { execFileSync } from "node:child_process";
+function executable(file) {
+    try {
+        fs.accessSync(file, fs.constants.X_OK);
+        return fs.statSync(file).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+export function stableNodeExecutable() {
+    const override = process.env.CODING_USAGE_BAR_NODE?.trim();
+    if (override) {
+        if (!override.startsWith("/") || !executable(override)) {
+            throw new Error(`CODING_USAGE_BAR_NODE must be an executable absolute path: ${override}`);
+        }
+        return override;
+    }
+    let pathNode = "";
+    try {
+        pathNode = execFileSync("/usr/bin/which", ["node"], { encoding: "utf8" }).trim();
+    }
+    catch {
+        // Fall through to known stable links and the current executable.
+    }
+    return [pathNode, "/opt/homebrew/bin/node", "/usr/local/bin/node", process.execPath]
+        .find((candidate) => candidate && executable(candidate)) ?? process.execPath;
+}

package/dist/notifier.d.ts

@@ -0,0 +1,7 @@
+import { BurnAnalysis, RuntimePaths } from "./types.js";
+export declare function commandExists(command: string): boolean;
+export declare function notificationBackend(): "osascript" | "terminal-notifier" | "burnt-toast" | "notify-send" | "unsupported";
+export declare function shouldNotify(analysis: BurnAnalysis, paths?: RuntimePaths, now?: Date): boolean;
+export declare function markNotified(analysis: BurnAnalysis, paths?: RuntimePaths, now?: Date): void;
+export declare function iconForAnalysis(analysis: BurnAnalysis): string;
+export declare function sendNotification(analysis: BurnAnalysis, dryRun?: boolean): string;

package/dist/notifier.js

@@ -0,0 +1,121 @@
+import { execFileSync, spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import os from "node:os";
+import { pathToFileURL } from "node:url";
+import { readJsonFile, writeJsonAtomic } from "./fs-util.js";
+import { buildPaths, installedAssetPath } from "./paths.js";
+import { formatDurationUntil } from "./format.js";
+import { writeNotificationCard } from "./card.js";
+export function commandExists(command) {
+    const result = spawnSync("/bin/sh", ["-c", `command -v ${command}`], {
+        stdio: "ignore",
+    });
+    return result.status === 0;
+}
+export function notificationBackend() {
+    if (process.platform === "darwin") {
+        return commandExists("terminal-notifier") ? "terminal-notifier" : "osascript";
+    }
+    if (process.platform === "win32") {
+        return "burnt-toast";
+    }
+    return commandExists("notify-send") ? "notify-send" : "unsupported";
+}
+function cooldownMinutes(profile) {
+    return profile === "high" ? 15 : 30;
+}
+function notificationKey(analysis) {
+    return `${analysis.provider}:${analysis.state}`;
+}
+export function shouldNotify(analysis, paths = buildPaths(), now = new Date()) {
+    if (analysis.state === "RAW" || analysis.state === "ON_TRACK") {
+        return false;
+    }
+    const state = readJsonFile(paths.notificationStateFile) ?? {};
+    const key = notificationKey(analysis);
+    const previous = state[key];
+    const resetAt = analysis.fiveHour?.resetsAt;
+    if (!previous) {
+        return true;
+    }
+    if (previous.resetAt && resetAt && previous.resetAt !== resetAt) {
+        return true;
+    }
+    const elapsedMinutes = (now.getTime() - Date.parse(previous.notifiedAt)) / 60_000;
+    return elapsedMinutes >= cooldownMinutes(analysis.profile);
+}
+export function markNotified(analysis, paths = buildPaths(), now = new Date()) {
+    const state = readJsonFile(paths.notificationStateFile) ?? {};
+    state[notificationKey(analysis)] = {
+        notifiedAt: now.toISOString(),
+        resetAt: analysis.fiveHour?.resetsAt,
+    };
+    writeJsonAtomic(paths.notificationStateFile, state);
+}
+function notificationText(analysis) {
+    const provider = analysis.provider === "claude" ? "Claude" : analysis.provider === "glm" ? "GLM" : "Codex";
+    const suffix = analysis.fiveHour ? `剩 ${formatDurationUntil(analysis.fiveHour.resetsAt)} 重置。` : "";
+    if (analysis.state === "UNDER_BURN") {
+        return {
+            title: `Coding Usage Bar: ${provider} 节奏偏慢`,
+            message: `${analysis.message} ${suffix}`.trim(),
+        };
+    }
+    if (analysis.state === "OVER_BURN") {
+        return {
+            title: `Coding Usage Bar: ${provider} 节奏过快`,
+            message: `${analysis.message} ${suffix}`.trim(),
+        };
+    }
+    return {
+        title: `Coding Usage Bar: ${provider} 接近限额`,
+        message: `${analysis.message} ${suffix}`.trim(),
+    };
+}
+export function iconForAnalysis(analysis) {
+    if (analysis.state === "UNDER_BURN") {
+        return installedAssetPath(os.homedir(), "coding-usage-bar-under.png");
+    }
+    if (analysis.state === "OVER_BURN") {
+        return installedAssetPath(os.homedir(), "coding-usage-bar-over.png");
+    }
+    if (analysis.state === "LIMIT_RISK") {
+        return installedAssetPath(os.homedir(), "coding-usage-bar-limit.png");
+    }
+    return installedAssetPath(os.homedir(), "coding-usage-bar-ok.png");
+}
+function iconUrl(iconPath) {
+    return pathToFileURL(iconPath).toString();
+}
+export function sendNotification(analysis, dryRun = false) {
+    const backend = notificationBackend();
+    const { title, message } = notificationText(analysis);
+    const appIcon = iconForAnalysis(analysis);
+    if (dryRun) {
+        return `[dry-run] ${backend}: dynamic-card ${title} - ${message}`;
+    }
+    if (backend === "terminal-notifier") {
+        const args = ["-title", title, "-message", message, "-group", `coding-usage-bar.${analysis.provider}`];
+        const cardPath = writeNotificationCard(analysis);
+        if (existsSync(cardPath)) {
+            args.push("-contentImage", iconUrl(cardPath));
+        }
+        if (existsSync(appIcon)) {
+            args.push("-appIcon", iconUrl(appIcon));
+        }
+        execFileSync("terminal-notifier", args);
+        return `${backend}: ${title}`;
+    }
+    if (backend === "osascript") {
+        execFileSync("osascript", ["-e", `display notification ${JSON.stringify(message)} with title ${JSON.stringify(title)}`]);
+        return `${backend}: ${title}`;
+    }
+    if (backend === "notify-send") {
+        execFileSync("notify-send", [title, message]);
+        return `${backend}: ${title}`;
+    }
+    if (os.platform() === "win32") {
+        throw new Error("Windows notification unavailable: install PowerShell module BurntToast.");
+    }
+    throw new Error("Desktop notification unavailable on this platform.");
+}

package/dist/paths.d.ts

@@ -0,0 +1,5 @@
+import { RuntimePaths, ProviderId } from "./types.js";
+export declare function buildPaths(homeDir?: string): RuntimePaths;
+export declare function installedAssetPath(homeDir: string, assetName: string): string;
+export declare function providerLatestPath(paths: RuntimePaths, provider: ProviderId): string;
+export declare function providerSamplesPath(paths: RuntimePaths, provider: ProviderId): string;

package/dist/paths.js

@@ -0,0 +1,45 @@
+import os from "node:os";
+import path from "node:path";
+export function buildPaths(homeDir = os.homedir()) {
+    const stateDir = path.join(homeDir, ".coding-usage-bar");
+    return {
+        homeDir,
+        stateDir,
+        configFile: path.join(stateDir, "config.json"),
+        claudeDir: path.join(stateDir, "claude"),
+        codexDir: path.join(stateDir, "codex"),
+        glmDir: path.join(stateDir, "glm"),
+        deepseekDir: path.join(stateDir, "deepseek"),
+        minimaxDir: path.join(stateDir, "minimax"),
+        notificationStateFile: path.join(stateDir, "notifications.json"),
+        statusFile: path.join(stateDir, "status.json"),
+        starPromptFile: path.join(stateDir, "star-prompt.json"),
+        cliBinDir: path.join(homeDir, ".local", "bin"),
+        cliBinFile: path.join(homeDir, ".local", "bin", "coding-usage-bar"),
+        swiftBarPluginDir: path.join(homeDir, "Library", "Application Support", "SwiftBar", "Plugins"),
+        swiftBarPluginFile: path.join(homeDir, "Library", "Application Support", "SwiftBar", "Plugins", "coding-usage-bar.1m.js"),
+        launchAgentFile: path.join(homeDir, "Library", "LaunchAgents", "com.duying.coding-usage-bar.plist"),
+        claudeSettingsFile: path.join(homeDir, ".claude", "settings.json"),
+        claudeStatusLineScript: path.join(stateDir, "claude", "statusline.sh"),
+    };
+}
+export function installedAssetPath(homeDir, assetName) {
+    return path.join(homeDir, ".coding-usage-bar", "app", "assets", assetName);
+}
+function providerDir(paths, provider) {
+    if (provider === "glm")
+        return paths.glmDir;
+    if (provider === "deepseek")
+        return paths.deepseekDir;
+    if (provider === "minimax")
+        return paths.minimaxDir;
+    if (provider === "claude")
+        return paths.claudeDir;
+    return paths.codexDir;
+}
+export function providerLatestPath(paths, provider) {
+    return path.join(providerDir(paths, provider), "latest.json");
+}
+export function providerSamplesPath(paths, provider) {
+    return path.join(providerDir(paths, provider), "samples.jsonl");
+}

package/dist/runtime.d.ts

@@ -0,0 +1,23 @@
+import { BurnAnalysis, BurnProfile, ProviderUsage, RuntimePaths, StatusIssue, StatusSnapshot } from "./types.js";
+export declare function loadFixtureUsages(fixturesDir: string): ProviderUsage[];
+export declare function collectLocalState(options?: {
+    fixtures?: boolean;
+}): Promise<{
+    usages: ProviderUsage[];
+    issues: StatusIssue[];
+}>;
+export declare function collectLocalUsages(options?: {
+    fixtures?: boolean;
+}): Promise<ProviderUsage[]>;
+export declare function analyzeUsages(usages: ProviderUsage[], profile: BurnProfile): BurnAnalysis[];
+export declare function readProfile(): BurnProfile;
+export declare function loadFixtureSamples(provider: string): ProviderUsage[];
+export declare function analyzeFixtureUsages(usages: ProviderUsage[], profile: BurnProfile): BurnAnalysis[];
+export declare function collectStatusSnapshot(options?: {
+    fixtures?: boolean;
+}): Promise<StatusSnapshot>;
+export declare function loadDisplayStatusSnapshot(options?: {
+    fixtures?: boolean;
+    refresh?: boolean;
+    paths?: RuntimePaths;
+}): StatusSnapshot;

package/dist/runtime.js

@@ -0,0 +1,244 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { readConfig } from "./config.js";
+import { collectCodexUsage } from "./codex.js";
+import { readJsonFile } from "./fs-util.js";
+import { collectGlmUsage } from "./glm.js";
+import { collectDeepseekUsage } from "./deepseek.js";
+import { collectMinimaxUsage } from "./minimax.js";
+import { buildPaths } from "./paths.js";
+import { loadLatestUsage, saveUsage } from "./store.js";
+import { createStatusSnapshot, loadStatusSnapshot, refreshStatusSnapshotFreshness, saveStatusSnapshot, } from "./status.js";
+const FIXTURES_DIR = fileURLToPath(new URL("../fixtures", import.meta.url));
+export function loadFixtureUsages(fixturesDir) {
+    const providers = ["claude", "codex", "glm", "deepseek", "minimax"];
+    return providers
+        .map((provider) => readJsonFile(path.join(fixturesDir, provider, "latest.json")))
+        .filter((item) => item !== null);
+}
+export async function collectLocalState(options = {}) {
+    if (options.fixtures) {
+        return { usages: loadFixtureUsages(FIXTURES_DIR), issues: [] };
+    }
+    const paths = buildPaths();
+    const config = readConfig(paths);
+    const monitored = new Set(config.providers);
+    const usages = [];
+    const issues = [];
+    if (monitored.has("codex")) {
+        try {
+            const codex = collectCodexUsage(path.join(paths.homeDir, ".codex"));
+            saveUsage(codex, paths);
+            usages.push(codex);
+        }
+        catch (error) {
+            const cached = loadLatestUsage("codex", paths);
+            if (cached) {
+                usages.push(cached);
+                issues.push({
+                    provider: "codex",
+                    severity: "warning",
+                    code: "CODEX_USING_CACHE",
+                    message: `Codex live usage unavailable; using cached usage from ${cached.observedAt}. ${error instanceof Error ? error.message : String(error)}`,
+                });
+            }
+            else {
+                issues.push({
+                    provider: "codex",
+                    severity: "error",
+                    code: "CODEX_USAGE_MISSING",
+                    message: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+    }
+    if (monitored.has("claude")) {
+        const claude = loadLatestUsage("claude", paths);
+        if (claude) {
+            usages.push(claude);
+        }
+        else {
+            issues.push({
+                provider: "claude",
+                severity: "warning",
+                code: "CLAUDE_INGEST_MISSING",
+                message: "Claude usage missing; add Coding Usage Bar ingest to Claude Code statusLine.command or remove claude from ~/.coding-usage-bar/config.json providers.",
+            });
+        }
+    }
+    if (monitored.has("glm")) {
+        const glmConfig = config.glm;
+        if (!glmConfig?.apiKey) {
+            issues.push({
+                provider: "glm",
+                severity: "warning",
+                code: "GLM_API_KEY_MISSING",
+                message: "GLM API key not configured. Edit ~/.coding-usage-bar/config.json to set glm.apiKey.",
+            });
+        }
+        else {
+            try {
+                const glm = await collectGlmUsage(glmConfig);
+                saveUsage(glm, paths);
+                usages.push(glm);
+            }
+            catch (error) {
+                const cached = loadLatestUsage("glm", paths);
+                if (cached) {
+                    usages.push(cached);
+                    issues.push({
+                        provider: "glm",
+                        severity: "warning",
+                        code: "GLM_USING_CACHE",
+                        message: `GLM live usage unavailable; using cached usage from ${cached.observedAt}. ${error instanceof Error ? error.message : String(error)}`,
+                    });
+                }
+                else {
+                    issues.push({
+                        provider: "glm",
+                        severity: "error",
+                        code: "GLM_USAGE_MISSING",
+                        message: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+        }
+    }
+    if (monitored.has("deepseek")) {
+        const deepseekConfig = config.deepseek;
+        if (!deepseekConfig?.apiKey) {
+            issues.push({
+                provider: "deepseek",
+                severity: "warning",
+                code: "DEEPSEEK_API_KEY_MISSING",
+                message: "DeepSeek API key not configured. Edit ~/.coding-usage-bar/config.json to set deepseek.apiKey.",
+            });
+        }
+        else {
+            try {
+                const deepseek = await collectDeepseekUsage(deepseekConfig);
+                saveUsage(deepseek, paths);
+                usages.push(deepseek);
+            }
+            catch (error) {
+                const cached = loadLatestUsage("deepseek", paths);
+                if (cached) {
+                    usages.push(cached);
+                    issues.push({
+                        provider: "deepseek",
+                        severity: "warning",
+                        code: "DEEPSEEK_USING_CACHE",
+                        message: `DeepSeek live balance unavailable; using cached data from ${cached.observedAt}. ${error instanceof Error ? error.message : String(error)}`,
+                    });
+                }
+                else {
+                    issues.push({
+                        provider: "deepseek",
+                        severity: "error",
+                        code: "DEEPSEEK_USAGE_MISSING",
+                        message: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+        }
+    }
+    if (monitored.has("minimax")) {
+        const minimaxConfig = config.minimax;
+        if (!minimaxConfig?.apiKey) {
+            issues.push({
+                provider: "minimax",
+                severity: "warning",
+                code: "MINIMAX_API_KEY_MISSING",
+                message: "MiniMax API key not configured. Edit ~/.coding-usage-bar/config.json to set minimax.apiKey.",
+            });
+        }
+        else {
+            try {
+                const minimax = await collectMinimaxUsage(minimaxConfig);
+                saveUsage(minimax, paths);
+                usages.push(minimax);
+            }
+            catch (error) {
+                const cached = loadLatestUsage("minimax", paths);
+                if (cached) {
+                    usages.push(cached);
+                    issues.push({
+                        provider: "minimax",
+                        severity: "warning",
+                        code: "MINIMAX_USING_CACHE",
+                        message: `MiniMax live usage unavailable; using cached usage from ${cached.observedAt}. ${error instanceof Error ? error.message : String(error)}`,
+                    });
+                }
+                else {
+                    issues.push({
+                        provider: "minimax",
+                        severity: "error",
+                        code: "MINIMAX_USAGE_MISSING",
+                        message: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+        }
+    }
+    return { usages, issues };
+}
+export async function collectLocalUsages(options = {}) {
+    return (await collectLocalState(options)).usages;
+}
+export function analyzeUsages(usages, profile) {
+    const paths = buildPaths();
+    return createStatusSnapshot(usages, profile, { paths }).providers.map((provider) => provider.analysis);
+}
+export function readProfile() {
+    const profile = process.env.CODING_USAGE_BAR_PROFILE;
+    return profile === "high" ? "high" : "low";
+}
+export function loadFixtureSamples(provider) {
+    const file = path.join(FIXTURES_DIR, provider, "samples.jsonl");
+    if (!fs.existsSync(file)) {
+        return [];
+    }
+    return fs
+        .readFileSync(file, "utf8")
+        .split(/\r?\n/)
+        .filter(Boolean)
+        .map((line) => JSON.parse(line));
+}
+export function analyzeFixtureUsages(usages, profile) {
+    const fixtureSamples = new Map(usages.map((usage) => [usage.provider, loadFixtureSamples(usage.provider)]));
+    return createStatusSnapshot(usages, profile, { fixtureSamples }).providers.map((provider) => provider.analysis);
+}
+export async function collectStatusSnapshot(options = {}) {
+    const { usages, issues } = await collectLocalState(options);
+    const profile = readProfile();
+    const fixtureSamples = options.fixtures
+        ? new Map(usages.map((usage) => [usage.provider, loadFixtureSamples(usage.provider)]))
+        : undefined;
+    const snapshot = createStatusSnapshot(usages, profile, { fixtureSamples, issues });
+    if (!options.fixtures) {
+        saveStatusSnapshot(snapshot);
+    }
+    return snapshot;
+}
+export function loadDisplayStatusSnapshot(options = {}) {
+    if (options.fixtures || options.refresh) {
+        throw new Error("Use collectStatusSnapshot() for async refresh; loadDisplayStatusSnapshot is sync (file-only)");
+    }
+    const snapshot = loadStatusSnapshot(options.paths);
+    if (snapshot) {
+        return refreshStatusSnapshotFreshness(snapshot);
+    }
+    return {
+        generatedAt: new Date().toISOString(),
+        profile: readProfile(),
+        providers: [],
+        issues: [
+            {
+                severity: "warning",
+                code: "STATUS_MISSING",
+                message: `No Coding Usage Bar status snapshot found at ${options.paths?.statusFile ?? buildPaths().statusFile}. Run coding-usage-bar daemon --once or coding-usage-bar status --refresh.`,
+            },
+        ],
+    };
+}

package/dist/star.d.ts

@@ -0,0 +1,15 @@
+import { RuntimePaths } from "./types.js";
+interface StarPromptOptions {
+    dryRun: boolean;
+    isInteractive?: boolean;
+    env?: Record<string, string | undefined>;
+    canStarWithGh?: boolean | (() => boolean);
+    confirmStar?: (prompt: string) => boolean;
+    starRepo?: (repo: string) => void;
+    now?: () => Date;
+}
+export declare function isStarConsent(answer: string): boolean;
+export declare function ghStarArgs(repo: string): string[];
+export declare function ghAuthStatusArgs(): string[];
+export declare function maybePromptForStar(paths: RuntimePaths, options: StarPromptOptions): string[];
+export {};