letmecode 0.1.21 → 0.1.22

package/ink-app/dist/providers/claude.js

@@ -10,12 +10,26 @@ import { applyRateLimits, asRecord, buildWindowLists, createLimitWindowAggregate
 import { addDailyUsage, buildDailyUsageRows, createDailyUsageAggregates } from "./daily.js";
 import { resolveUsageRate } from "./pricing.js";
 const RATE_CARD = {
+    "claude-fable-5": { input: 10, cacheRead: 1, cacheWrite: 12.5, cacheWrite5m: 12.5, cacheWrite1h: 20, output: 50 },
     "claude-opus-4-8": { input: 5, cacheRead: 0.5, cacheWrite: 6.25, cacheWrite5m: 6.25, cacheWrite1h: 10, output: 25 },
     "claude-opus-4-7": { input: 5, cacheRead: 0.5, cacheWrite: 6.25, cacheWrite5m: 6.25, cacheWrite1h: 10, output: 25 },
     "claude-opus-4-6": { input: 5, cacheRead: 0.5, cacheWrite: 6.25, cacheWrite5m: 6.25, cacheWrite1h: 10, output: 25 },
     "claude-opus-4-5": { input: 5, cacheRead: 0.5, cacheWrite: 6.25, cacheWrite5m: 6.25, cacheWrite1h: 10, output: 25 },
     "claude-opus-4-1": { input: 15, cacheRead: 1.5, cacheWrite: 18.75, cacheWrite5m: 18.75, cacheWrite1h: 30, output: 75 },
     "claude-opus-4": { input: 15, cacheRead: 1.5, cacheWrite: 18.75, cacheWrite5m: 18.75, cacheWrite1h: 30, output: 75 },
+    "claude-sonnet-5": {
+        input: 3,
+        cacheRead: 0.3,
+        cacheWrite: 3.75,
+        cacheWrite5m: 3.75,
+        cacheWrite1h: 6,
+        output: 15,
+        // Intro pricing (~0.66x) through 2026-08-31; reverts to the standard rate above on 2026-09-01.
+        introOffer: {
+            effectiveUntilMs: Date.UTC(2026, 8, 1),
+            rate: { input: 2, cacheRead: 0.2, cacheWrite: 2.5, cacheWrite5m: 2.5, cacheWrite1h: 4, output: 10 }
+        }
+    },
     "claude-sonnet-4-6": { input: 3, cacheRead: 0.3, cacheWrite: 3.75, cacheWrite5m: 3.75, cacheWrite1h: 6, output: 15 },
     "claude-sonnet-4-5": { input: 3, cacheRead: 0.3, cacheWrite: 3.75, cacheWrite5m: 3.75, cacheWrite1h: 6, output: 15 },
     "claude-sonnet-4": { input: 3, cacheRead: 0.3, cacheWrite: 3.75, cacheWrite5m: 3.75, cacheWrite1h: 6, output: 15 },
@@ -46,12 +60,14 @@ const parsedClaudeSessionFilesCache = new Map();
 const claudeBinaryPathCache = new Map();
 const claudeUsageOutputCache = new Map();
 const claudeAuthStatusOutputCache = new Map();
+const claudeOauthCredentialsOutputCache = new Map();
 export class ClaudeUsageProvider extends UsageProviderBase {
     constructor(options = {}) {
         super(options.id ?? "claude", options.label ?? "Claude");
         this.root = path.resolve(options.root ?? os.homedir());
         this.readUsageCommandOutput = options.readUsageCommandOutput;
         this.readAuthStatusOutput = options.readAuthStatusOutput;
+        this.readOauthCredentials = options.readOauthCredentials;
         this.now = options.now ?? (() => new Date());
     }
     async getStats(options = {}) {
@@ -147,7 +163,7 @@ export class ClaudeUsageProvider extends UsageProviderBase {
         const liveLimitWindows = await buildLiveLimitWindows({
             root: this.root,
             readUsageCommandOutput: this.readUsageCommandOutput,
-            readAuthStatusOutput: this.readAuthStatusOutput,
+            readOauthCredentials: this.readOauthCredentials,
             traceLogger: options.traceLogger,
             now: this.now(),
             selectedEvents
@@ -212,14 +228,14 @@ function normalizeUsage(value) {
         inferenceGeo: String(usage.inference_geo ?? "")
     };
 }
-function resolveRate(modelId) {
-    return resolveUsageRate(RATE_CARD, modelId, 0, { prefixMatch: true });
+function resolveRate(modelId, timestampMs) {
+    return resolveUsageRate(RATE_CARD, modelId, 0, { prefixMatch: true, timestampMs });
 }
 function isInternalClaudeModel(modelId) {
     return modelId === "<synthetic>";
 }
-function creditsFor(modelId, usage) {
-    const rate = resolveRate(modelId);
+function creditsFor(modelId, usage, timestampMs) {
+    const rate = resolveRate(modelId, timestampMs);
     if (!rate) {
         return 0;
     }
@@ -233,7 +249,7 @@ function creditsFor(modelId, usage) {
         inferenceMultiplier *
         USD_TO_CREDITS);
 }
-function usageToTotals(modelId, usage) {
+function usageToTotals(modelId, usage, timestampMs) {
     const cacheWriteBreakdown = resolveClaudeCacheWriteBreakdown(usage);
     const cacheWriteInputTokens = cacheWriteBreakdown.cacheWrite5mInputTokens +
         cacheWriteBreakdown.cacheWrite1hInputTokens;
@@ -249,7 +265,7 @@ function usageToTotals(modelId, usage) {
             usage.cacheReadInputTokens +
             cacheWriteInputTokens +
             usage.outputTokens,
-        estimatedCredits: creditsFor(modelId, usage),
+        estimatedCredits: creditsFor(modelId, usage, timestampMs),
         eventCount: 1
     };
 }
@@ -437,7 +453,7 @@ async function parseSessionFile(filePath) {
             timestampMs: eventTimeMs,
             modelId,
             usage: normalizedUsage,
-            totals: usageToTotals(modelId, normalizedUsage),
+            totals: usageToTotals(modelId, normalizedUsage, eventTimeMs),
             rateLimits
         });
     }
@@ -546,7 +562,7 @@ function mergeParsedUsageEvents(previous, next) {
         timestampMs: Math.max(normalizeTimestamp(previous.timestampMs), normalizeTimestamp(next.timestampMs)),
         modelId,
         usage,
-        totals: usageToTotals(modelId, usage),
+        totals: usageToTotals(modelId, usage, primaryEvent.timestampMs),
         rateLimits: latestEvent.rateLimits ?? previous.rateLimits ?? next.rateLimits
     };
 }
@@ -648,16 +664,16 @@ function buildClaudeCommandEnvironment() {
     };
 }
 async function buildLiveLimitWindows(options) {
-    const [usageOutput, subscriptionType] = await Promise.all([
+    const [usageOutput, credentials] = await Promise.all([
         readClaudeUsageCommandOutput(options.root, options.readUsageCommandOutput, options.traceLogger),
-        readClaudeSubscriptionType(options.root, options.readAuthStatusOutput, options.traceLogger)
+        readClaudeOauthCredentials(options.root, options.readOauthCredentials, options.traceLogger)
     ]);
     const snapshots = parseLiveUsageWindowSnapshots(usageOutput, options.now);
     traceClaude(options.traceLogger, `Parsed ${snapshots.length} live usage snapshot(s) from /usage output.`);
     if (snapshots.length === 0) {
         traceClaude(options.traceLogger, "No live usage snapshots matched the expected /usage format.");
     }
-    const resolvedPlanType = resolveClaudeLivePlanType(subscriptionType, snapshots);
+    const resolvedPlanType = resolveClaudeLivePlanType(credentials);
     traceClaude(options.traceLogger, `Resolved live plan type ${resolvedPlanType}.`);
     const primaryLimitWindows = snapshots
         .filter((snapshot) => snapshot.scope === "primary")
@@ -690,20 +706,82 @@ async function buildLiveLimitWindows(options) {
         secondaryLimitWindows
     };
 }
-function resolveClaudeLivePlanType(subscriptionType, snapshots) {
-    if (snapshots.some((snapshot) => snapshot.modelScope === "sonnet-only")) {
-        return "team_premium";
+// Reported as-is: the claude.ai OAuth `rateLimitTier` is not mapped to a friendly tier name
+// anymore, it is combined with `subscriptionType` verbatim (e.g. "team|default_claude_max_5x").
+function resolveClaudeLivePlanType(credentials) {
+    const subscriptionType = credentials?.subscriptionType;
+    if (!subscriptionType) {
+        return "live";
+    }
+    return credentials?.rateLimitTier ? `${subscriptionType}|${credentials.rateLimitTier}` : subscriptionType;
+}
+async function readClaudeOauthCredentials(root, override, traceLogger) {
+    const output = await readClaudeOauthCredentialsOutput(root, override, traceLogger);
+    const credentials = parseClaudeOauthCredentials(output);
+    if (output && !credentials) {
+        traceClaude(traceLogger, "Could not parse claude.ai OAuth credentials from credentials file.");
+    }
+    traceClaude(traceLogger, `OAuth credentials result: subscriptionType=${credentials?.subscriptionType ?? "<none>"} rateLimitTier=${credentials?.rateLimitTier ?? "<none>"}.`);
+    return credentials;
+}
+async function readClaudeOauthCredentialsOutput(root, override, traceLogger) {
+    if (override) {
+        try {
+            const output = await override();
+            traceClaude(traceLogger, "Using injected OAuth credentials override.");
+            return output;
+        }
+        catch {
+            traceClaude(traceLogger, "Injected OAuth credentials override failed.");
+            return null;
+        }
+    }
+    const credentialsPath = path.join(path.resolve(root), ".claude", ".credentials.json");
+    const cacheKey = credentialsPath;
+    const cached = claudeOauthCredentialsOutputCache.get(cacheKey);
+    if (cached) {
+        traceClaude(traceLogger, "OAuth credentials cache hit.");
+        return cached;
     }
-    return subscriptionType || "live";
+    const pending = (async () => {
+        try {
+            const output = await fs.promises.readFile(credentialsPath, { encoding: "utf8" });
+            traceClaude(traceLogger, `Read OAuth credentials from ${credentialsPath}.`);
+            return output;
+        }
+        catch {
+            traceClaude(traceLogger, `No readable OAuth credentials at ${credentialsPath}.`);
+            return null;
+        }
+    })();
+    claudeOauthCredentialsOutputCache.set(cacheKey, pending);
+    return pending;
 }
-async function readClaudeSubscriptionType(root, override, traceLogger) {
-    const output = await readClaudeAuthStatusOutput(root, override, traceLogger);
-    const subscriptionType = parseClaudeSubscriptionType(output);
-    if (output && !subscriptionType) {
-        traceClaude(traceLogger, "Could not parse subscription type from auth status output.");
-    }
-    traceClaude(traceLogger, `Subscription type result: ${subscriptionType ?? "<none>"}.`);
-    return subscriptionType;
+function parseClaudeOauthCredentials(output) {
+    if (!output) {
+        return null;
+    }
+    let payload;
+    try {
+        payload = JSON.parse(output);
+    }
+    catch {
+        return null;
+    }
+    const oauth = asRecord(asRecord(payload)?.claudeAiOauth);
+    if (!oauth) {
+        return null;
+    }
+    const subscriptionType = typeof oauth.subscriptionType === "string" && oauth.subscriptionType.trim()
+        ? oauth.subscriptionType.trim()
+        : null;
+    const rateLimitTier = typeof oauth.rateLimitTier === "string" && oauth.rateLimitTier.trim()
+        ? oauth.rateLimitTier.trim()
+        : null;
+    if (!subscriptionType && !rateLimitTier) {
+        return null;
+    }
+    return { subscriptionType, rateLimitTier };
 }
 async function readClaudeAuthStatusOutput(root, override, traceLogger) {
     if (override) {
@@ -751,10 +829,6 @@ async function readClaudeAuthStatusOutput(root, override, traceLogger) {
     claudeAuthStatusOutputCache.set(cacheKey, pending);
     return pending;
 }
-function parseClaudeSubscriptionType(output) {
-    const snapshot = parseClaudeAuthStatusSnapshot(output);
-    return snapshot?.subscriptionType ?? null;
-}
 function parseClaudeAuthStatusSnapshot(output) {
     if (!output) {
         return null;
@@ -977,9 +1051,6 @@ function parseLiveUsageWindowSnapshots(usageOutput, now) {
             resetString: match[4]?.trim() || null
         });
     }
-    // Per-scope reset times printed by Claude. Lines like "Current week (Sonnet
-    // only)" omit the reset because it is identical to the "all models" week, so
-    // a missing reset inherits the resolved reset of the same scope.
     const resetMsByLabel = new Map();
     for (const parsed of parsedLines) {
         if (!parsed.resetString || resetMsByLabel.has(parsed.label)) {
@@ -996,14 +1067,17 @@ function parseLiveUsageWindowSnapshots(usageOutput, now) {
         if (!resetsAtMs) {
             continue;
         }
-        const isSonnetOnlyWeek = parsed.label === "week" && parsed.windowQualifier === "sonnet only";
-        const limitId = isSonnetOnlyWeek ? "current-week-sonnet-only" : `current-${parsed.label}`;
+        const isModelScopedWeek = parsed.label === "week" && parsed.windowQualifier !== "" && parsed.windowQualifier !== "all models";
+        const modelFamily = isModelScopedWeek ? parsed.windowQualifier.replace(/\s+only$/, "") : null;
+        const limitId = modelFamily
+            ? `current-week-${modelFamily.replace(/\s+/g, "-")}-only`
+            : `current-${parsed.label}`;
         snapshots.set(limitId, {
             scope: parsed.label === "session" ? "primary" : "secondary",
             label: parsed.label,
             limitId,
-            modelScope: isSonnetOnlyWeek ? "sonnet-only" : "all-models",
-            modelType: isSonnetOnlyWeek ? "sonnet only" : undefined,
+            modelFamily,
+            modelType: modelFamily ? parsed.windowQualifier : undefined,
             usedPercent: parsed.usedPercent,
             resetsAtMs,
             windowMinutes: parsed.windowMinutes
@@ -1087,10 +1161,10 @@ function buildLiveLimitWindowRow(snapshot, planType, selectedEvents, now) {
     };
 }
 function matchesClaudeLiveSnapshotModelScope(snapshot, modelId) {
-    if (snapshot.modelScope !== "sonnet-only") {
+    if (!snapshot.modelFamily) {
         return true;
     }
-    return modelId.toLowerCase().includes("sonnet");
+    return modelId.toLowerCase().includes(snapshot.modelFamily);
 }
 function buildModelUsageRowsForEvents(events) {
     const byModel = new Map();

package/ink-app/dist/providers/pricing.js

@@ -14,5 +14,10 @@ export function resolveUsageRate(rateCard, modelId, inputTokens = 0, options = {
     if (rate.longContext && inputTokens > rate.longContext.thresholdTokens) {
         return rate.longContext.rate;
     }
+    if (rate.introOffer &&
+        Number.isFinite(options.timestampMs) &&
+        options.timestampMs < rate.introOffer.effectiveUntilMs) {
+        return rate.introOffer.rate;
+    }
     return rate;
 }

package/ink-app/dist/reporting.js

@@ -64,7 +64,11 @@ function resolveReportModelType(stats, window) {
     return truncateSchemaString(stats.providerId, 128);
 }
 function resolveClaudeReportModelType(window) {
-    return window.modelType?.toLowerCase().includes("sonnet") ? "sonnet-only" : "all";
+    const modelFamily = window.modelType?.toLowerCase().replace(/\s+only$/, "").trim();
+    if (!modelFamily) {
+        return "all";
+    }
+    return truncateSchemaString(`${modelFamily.replace(/\s+/g, "-")}-only`, 128);
 }
 function resolveAntigravityReportModelType(stats, window) {
     const limitId = window.limitId.toLowerCase();

package/package.json

@@ -1,10 +1,9 @@
 {
   "name": "letmecode",
-  "version": "0.1.21",
+  "version": "0.1.22",
   "description": "Provider-based terminal usage dashboard for LetMeCode.",
   "author": "devforth.io",
   "license": "MIT",
-  "packageManager": "pnpm@10.28.2",
   "type": "commonjs",
   "bin": {
     "letmecode": "./bin/letmecode.js"
@@ -21,16 +20,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true }); require('node:fs').rmSync('ink-app/dist', { recursive: true, force: true });\"",
-    "build": "npm run clean && tsc -p tsconfig.json && tsc -p ink-app/tsconfig.json",
-    "prepack": "npm run build",
-    "prestart": "npm run build",
-    "start": "node ./bin/letmecode.js",
-    "pretest": "npm run build",
-    "smoke": "node ./bin/letmecode.js",
-    "test": "node --test ink-app/test/*.test.mjs"
-  },
   "keywords": [
     "cli",
     "ink",
@@ -46,5 +35,14 @@
     "@types/node": "^24.0.7",
     "@types/react": "^18.3.24",
     "typescript": "^5.8.3"
+  },
+  "scripts": {
+    "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true }); require('node:fs').rmSync('ink-app/dist', { recursive: true, force: true });\"",
+    "build": "npm run clean && tsc -p tsconfig.json && tsc -p ink-app/tsconfig.json",
+    "prestart": "npm run build",
+    "start": "node ./bin/letmecode.js",
+    "pretest": "npm run build",
+    "smoke": "node ./bin/letmecode.js",
+    "test": "node --test ink-app/test/*.test.mjs"
   }
-}
+}