@tokscale/cli 1.0.17 → 1.0.18

package/src/graph-types.ts

@@ -6,7 +6,7 @@
 /**
  * Valid source identifiers
  */
-export type SourceType = "opencode" | "claude" | "codex" | "gemini" | "cursor";
+export type SourceType = "opencode" | "claude" | "codex" | "gemini" | "cursor" | "amp" | "droid";
 
 /**
  * Token breakdown by category

package/src/native-runner.ts

@@ -76,16 +76,16 @@ async function main() {
       result = nativeCore.parseLocalSources(args[0] as Parameters<typeof nativeCore.parseLocalSources>[0]);
       break;
     case "finalizeReport":
-      result = nativeCore.finalizeReport(args[0] as Parameters<typeof nativeCore.finalizeReport>[0]);
+      result = await nativeCore.finalizeReport(args[0] as Parameters<typeof nativeCore.finalizeReport>[0]);
       break;
     case "finalizeMonthlyReport":
-      result = nativeCore.finalizeMonthlyReport(args[0] as Parameters<typeof nativeCore.finalizeMonthlyReport>[0]);
+      result = await nativeCore.finalizeMonthlyReport(args[0] as Parameters<typeof nativeCore.finalizeMonthlyReport>[0]);
       break;
     case "finalizeGraph":
-      result = nativeCore.finalizeGraph(args[0] as Parameters<typeof nativeCore.finalizeGraph>[0]);
+      result = await nativeCore.finalizeGraph(args[0] as Parameters<typeof nativeCore.finalizeGraph>[0]);
       break;
-    case "generateGraphWithPricing":
-      result = nativeCore.generateGraphWithPricing(args[0] as Parameters<typeof nativeCore.generateGraphWithPricing>[0]);
+    case "finalizeReportAndGraph":
+      result = await nativeCore.finalizeReportAndGraph(args[0] as Parameters<typeof nativeCore.finalizeReportAndGraph>[0]);
       break;
     default:
       throw new Error(`Unknown method: ${method}`);

package/src/native.ts

@@ -2,48 +2,19 @@
  * Native module loader for Rust core
  *
  * Exposes all Rust functions with proper TypeScript types.
- * Falls back to TypeScript implementations when native module is unavailable.
+ * Native module is REQUIRED - no TypeScript fallback.
  */
 
-import type { PricingEntry } from "./pricing.js";
 import type {
   TokenContributionData,
   GraphOptions as TSGraphOptions,
   SourceType,
 } from "./graph-types.js";
-import {
-  parseLocalSources as parseLocalSourcesTS,
-  type ParsedMessages as TSParsedMessages,
-  type UnifiedMessage,
-} from "./sessions/index.js";
-import {
-  generateModelReport as generateModelReportTS,
-  generateMonthlyReport as generateMonthlyReportTS,
-  generateGraphData as generateGraphDataTS,
-} from "./sessions/reports.js";
-import { readCursorMessagesFromCache } from "./cursor.js";
 
 // =============================================================================
 // Types matching Rust exports
 // =============================================================================
 
-interface NativeGraphOptions {
-  homeDir?: string;
-  sources?: string[];
-  since?: string;
-  until?: string;
-  year?: string;
-  threads?: number;
-}
-
-interface NativeScanStats {
-  opencodeFiles: number;
-  claudeFiles: number;
-  codexFiles: number;
-  geminiFiles: number;
-  totalFiles: number;
-}
-
 interface NativeTokenBreakdown {
   input: number;
   output: number;
@@ -109,21 +80,9 @@ interface NativeGraphResult {
   contributions: NativeDailyContribution[];
 }
 
-// Types for pricing-aware APIs
-interface NativePricingEntry {
-  modelId: string;
-  pricing: {
-    inputCostPerToken: number;
-    outputCostPerToken: number;
-    cacheReadInputTokenCost?: number;
-    cacheCreationInputTokenCost?: number;
-  };
-}
-
 interface NativeReportOptions {
   homeDir?: string;
   sources?: string[];
-  pricing: NativePricingEntry[];
   since?: string;
   until?: string;
   year?: string;
@@ -192,6 +151,8 @@ interface NativeParsedMessages {
   claudeCount: number;
   codexCount: number;
   geminiCount: number;
+  ampCount: number;
+  droidCount?: number;
   processingTimeMs: number;
 }
 
@@ -206,7 +167,6 @@ interface NativeLocalParseOptions {
 interface NativeFinalizeReportOptions {
   homeDir?: string;
   localMessages: NativeParsedMessages;
-  pricing: NativePricingEntry[];
   includeCursor: boolean;
   since?: string;
   until?: string;
@@ -216,12 +176,6 @@ interface NativeFinalizeReportOptions {
 interface NativeCore {
   version(): string;
   healthCheck(): string;
-  generateGraph(options: NativeGraphOptions): NativeGraphResult;
-  generateGraphWithPricing(options: NativeReportOptions): NativeGraphResult;
-  scanSessions(homeDir?: string, sources?: string[]): NativeScanStats;
-  getModelReport(options: NativeReportOptions): NativeModelReport;
-  getMonthlyReport(options: NativeReportOptions): NativeMonthlyReport;
-  // Two-phase processing (parallel optimization)
   parseLocalSources(options: NativeLocalParseOptions): NativeParsedMessages;
   finalizeReport(options: NativeFinalizeReportOptions): NativeModelReport;
   finalizeMonthlyReport(options: NativeFinalizeReportOptions): NativeMonthlyReport;
@@ -236,7 +190,11 @@ let nativeCore: NativeCore | null = null;
 let loadError: Error | null = null;
 
 try {
-  nativeCore = await import("@tokscale/core").then((m) => m.default || m);
+  // Type assertion needed because dynamic import returns module namespace
+  // nativeCore.version() is called directly, async functions go through subprocess
+  nativeCore = await import("@tokscale/core").then(
+    (m) => (m.default || m) as unknown as NativeCore
+  );
 } catch (e) {
   loadError = e as Error;
 }
@@ -252,13 +210,6 @@ export function isNativeAvailable(): boolean {
   return nativeCore !== null;
 }
 
-/**
- * Get native module load error (if any)
- */
-export function getNativeLoadError(): Error | null {
-  return loadError;
-}
-
 /**
  * Get native module version
  */
@@ -266,33 +217,6 @@ export function getNativeVersion(): string | null {
   return nativeCore?.version() ?? null;
 }
 
-/**
- * Scan sessions using native module
- */
-export function scanSessionsNative(homeDir?: string, sources?: string[]): NativeScanStats | null {
-  if (!nativeCore) {
-    return null;
-  }
-  return nativeCore.scanSessions(homeDir, sources);
-}
-
-// =============================================================================
-// Graph generation
-// =============================================================================
-
-/**
- * Convert TypeScript graph options to native format
- */
-function toNativeOptions(options: TSGraphOptions): NativeGraphOptions {
-  return {
-    homeDir: undefined,
-    sources: options.sources,
-    since: options.since,
-    until: options.until,
-    year: options.year,
-  };
-}
-
 /**
  * Convert native result to TypeScript format
  */
@@ -358,22 +282,6 @@ function fromNativeResult(result: NativeGraphResult): TokenContributionData {
   };
 }
 
-/**
- * Generate graph data using native module (without pricing - uses embedded costs)
- * @deprecated Use generateGraphWithPricing instead
- */
-export function generateGraphNative(options: TSGraphOptions = {}): TokenContributionData {
-  if (!nativeCore) {
-    throw new Error("Native module not available: " + (loadError?.message || "unknown error"));
-  }
-
-  const nativeOptions = toNativeOptions(options);
-  const result = nativeCore.generateGraph(nativeOptions);
-  return fromNativeResult(result);
-}
-
-
-
 // =============================================================================
 // Reports
 // =============================================================================
@@ -442,6 +350,8 @@ export interface ParsedMessages {
   claudeCount: number;
   codexCount: number;
   geminiCount: number;
+  ampCount: number;
+  droidCount: number;
   processingTimeMs: number;
 }
 
@@ -450,13 +360,10 @@ export interface LocalParseOptions {
   since?: string;
   until?: string;
   year?: string;
-  /** Force TypeScript fallback even when native module is available (needed for agent field) */
-  forceTypescript?: boolean;
 }
 
 export interface FinalizeOptions {
   localMessages: ParsedMessages;
-  pricing: PricingEntry[];
   includeCursor: boolean;
   since?: string;
   until?: string;
@@ -641,36 +548,8 @@ async function runInSubprocess<T>(method: string, args: unknown[]): Promise<T> {
 }
 
 export async function parseLocalSourcesAsync(options: LocalParseOptions): Promise<ParsedMessages> {
-  // Use TypeScript fallback when native module is not available or when explicitly requested
-  if (!isNativeAvailable() || options.forceTypescript) {
-    const result = parseLocalSourcesTS({
-      sources: options.sources,
-      since: options.since,
-      until: options.until,
-      year: options.year,
-    });
-
-    return {
-      messages: result.messages.map((msg) => ({
-        source: msg.source,
-        modelId: msg.modelId,
-        providerId: msg.providerId,
-        timestamp: msg.timestamp,
-        date: msg.date,
-        input: msg.tokens.input,
-        output: msg.tokens.output,
-        cacheRead: msg.tokens.cacheRead,
-        cacheWrite: msg.tokens.cacheWrite,
-        reasoning: msg.tokens.reasoning,
-        sessionId: msg.sessionId,
-        agent: msg.agent,
-      })),
-      opencodeCount: result.opencodeCount,
-      claudeCount: result.claudeCount,
-      codexCount: result.codexCount,
-      geminiCount: result.geminiCount,
-      processingTimeMs: result.processingTimeMs,
-    };
+  if (!isNativeAvailable()) {
+    throw new Error("Native module required. Run: bun run build:core");
   }
 
   const nativeOptions: NativeLocalParseOptions = {
@@ -684,52 +563,14 @@ export async function parseLocalSourcesAsync(options: LocalParseOptions): Promis
   return runInSubprocess<ParsedMessages>("parseLocalSources", [nativeOptions]);
 }
 
-function buildMessagesForFallback(options: FinalizeOptions): UnifiedMessage[] {
-  const messages: UnifiedMessage[] = options.localMessages.messages.map((msg) => ({
-    source: msg.source,
-    modelId: msg.modelId,
-    providerId: msg.providerId,
-    sessionId: msg.sessionId,
-    timestamp: msg.timestamp,
-    date: msg.date,
-    tokens: {
-      input: msg.input,
-      output: msg.output,
-      cacheRead: msg.cacheRead,
-      cacheWrite: msg.cacheWrite,
-      reasoning: msg.reasoning,
-    },
-    cost: 0,
-    agent: msg.agent,
-  }));
-
-  if (options.includeCursor) {
-    const cursorMessages = readCursorMessagesFromCache();
-    for (const cursor of cursorMessages) {
-      const inRange =
-        (!options.year || cursor.date.startsWith(options.year)) &&
-        (!options.since || cursor.date >= options.since) &&
-        (!options.until || cursor.date <= options.until);
-      if (inRange) {
-        messages.push(cursor);
-      }
-    }
-  }
-
-  return messages;
-}
-
 export async function finalizeReportAsync(options: FinalizeOptions): Promise<ModelReport> {
   if (!isNativeAvailable()) {
-    const startTime = performance.now();
-    const messages = buildMessagesForFallback(options);
-    return generateModelReportTS(messages, options.pricing, startTime);
+    throw new Error("Native module required. Run: bun run build:core");
   }
 
   const nativeOptions: NativeFinalizeReportOptions = {
     homeDir: undefined,
     localMessages: options.localMessages,
-    pricing: options.pricing,
     includeCursor: options.includeCursor,
     since: options.since,
     until: options.until,
@@ -741,15 +582,12 @@ export async function finalizeReportAsync(options: FinalizeOptions): Promise<Mod
 
 export async function finalizeMonthlyReportAsync(options: FinalizeOptions): Promise<MonthlyReport> {
   if (!isNativeAvailable()) {
-    const startTime = performance.now();
-    const messages = buildMessagesForFallback(options);
-    return generateMonthlyReportTS(messages, options.pricing, startTime);
+    throw new Error("Native module required. Run: bun run build:core");
   }
 
   const nativeOptions: NativeFinalizeReportOptions = {
     homeDir: undefined,
     localMessages: options.localMessages,
-    pricing: options.pricing,
     includeCursor: options.includeCursor,
     since: options.since,
     until: options.until,
@@ -761,15 +599,12 @@ export async function finalizeMonthlyReportAsync(options: FinalizeOptions): Prom
 
 export async function finalizeGraphAsync(options: FinalizeOptions): Promise<TokenContributionData> {
   if (!isNativeAvailable()) {
-    const startTime = performance.now();
-    const messages = buildMessagesForFallback(options);
-    return generateGraphDataTS(messages, options.pricing, startTime);
+    throw new Error("Native module required. Run: bun run build:core");
   }
 
   const nativeOptions: NativeFinalizeReportOptions = {
     homeDir: undefined,
     localMessages: options.localMessages,
-    pricing: options.pricing,
     includeCursor: options.includeCursor,
     since: options.since,
     until: options.until,
@@ -780,33 +615,33 @@ export async function finalizeGraphAsync(options: FinalizeOptions): Promise<Toke
   return fromNativeResult(result);
 }
 
-export async function generateGraphWithPricingAsync(
-  options: TSGraphOptions & { pricing: PricingEntry[] }
-): Promise<TokenContributionData> {
-  // Use TypeScript fallback when native module is not available
-  if (!isNativeAvailable()) {
-    const startTime = performance.now();
-
-    // Parse local sources using TS fallback
-    const parsed = parseLocalSourcesTS({
-      sources: options.sources,
-      since: options.since,
-      until: options.until,
-      year: options.year,
-    });
+export interface ReportAndGraph {
+  report: ModelReport;
+  graph: TokenContributionData;
+}
+
+interface NativeReportAndGraph {
+  report: NativeModelReport;
+  graph: NativeGraphResult;
+}
 
-    return generateGraphDataTS(parsed.messages, options.pricing, startTime);
+export async function finalizeReportAndGraphAsync(options: FinalizeOptions): Promise<ReportAndGraph> {
+  if (!isNativeAvailable()) {
+    throw new Error("Native module required. Run: bun run build:core");
   }
 
-  const nativeOptions: NativeReportOptions = {
+  const nativeOptions: NativeFinalizeReportOptions = {
     homeDir: undefined,
-    sources: options.sources,
-    pricing: options.pricing,
+    localMessages: options.localMessages,
+    includeCursor: options.includeCursor,
     since: options.since,
     until: options.until,
     year: options.year,
   };
 
-  const result = await runInSubprocess<NativeGraphResult>("generateGraphWithPricing", [nativeOptions]);
-  return fromNativeResult(result);
+  const result = await runInSubprocess<NativeReportAndGraph>("finalizeReportAndGraph", [nativeOptions]);
+  return {
+    report: result.report,
+    graph: fromNativeResult(result.graph),
+  };
 }

package/src/sessions/types.ts

@@ -22,7 +22,7 @@ export interface UnifiedMessage {
   agent?: string;
 }
 
-export type SourceType = "opencode" | "claude" | "codex" | "gemini" | "cursor";
+export type SourceType = "opencode" | "claude" | "codex" | "gemini" | "cursor" | "amp" | "droid";
 
 /**
  * Convert Unix milliseconds timestamp to YYYY-MM-DD date string

package/src/submit.ts

@@ -5,11 +5,8 @@
 
 import pc from "picocolors";
 import { loadCredentials, getApiBaseUrl } from "./credentials.js";
-import { PricingFetcher } from "./pricing.js";
-import {
-  isNativeAvailable,
-  generateGraphWithPricingAsync,
-} from "./native.js";
+import { parseLocalSourcesAsync, finalizeReportAndGraphAsync, type ParsedMessages } from "./native.js";
+import { syncCursorCache, loadCursorCredentials } from "./cursor.js";
 import type { TokenContributionData } from "./graph-types.js";
 import { formatCurrency } from "./table.js";
 
@@ -19,6 +16,8 @@ interface SubmitOptions {
   codex?: boolean;
   gemini?: boolean;
   cursor?: boolean;
+  amp?: boolean;
+  droid?: boolean;
   since?: string;
   until?: string;
   year?: string;
@@ -44,7 +43,7 @@ interface SubmitResponse {
   details?: string[];
 }
 
-type SourceType = "opencode" | "claude" | "codex" | "gemini" | "cursor";
+type SourceType = "opencode" | "claude" | "codex" | "gemini" | "cursor" | "amp" | "droid";
 
 /**
  * Submit command - sends usage data to the platform
@@ -58,24 +57,13 @@ export async function submit(options: SubmitOptions = {}): Promise<void> {
     process.exit(1);
   }
 
-  // Step 2: Log native module status (TS fallback available)
-  if (!isNativeAvailable()) {
-    console.log(pc.yellow("\n  Note: Using TypeScript fallback (native module not available)"));
-    console.log(pc.gray("  Run 'bun run build:core' for faster processing.\n"));
-  }
-
   console.log(pc.cyan("\n  Tokscale - Submit Usage Data\n"));
 
-  // Step 3: Generate graph data
   console.log(pc.gray("  Scanning local session data..."));
 
-  const fetcher = new PricingFetcher();
-  await fetcher.fetchPricing();
-  const pricingEntries = fetcher.toPricingEntries();
-
-  // Determine sources
-  const hasFilter = options.opencode || options.claude || options.codex || options.gemini || options.cursor;
+  const hasFilter = options.opencode || options.claude || options.codex || options.gemini || options.cursor || options.amp || options.droid;
   let sources: SourceType[] | undefined;
+  let includeCursor = true;
   if (hasFilter) {
     sources = [];
     if (options.opencode) sources.push("opencode");
@@ -83,17 +71,43 @@ export async function submit(options: SubmitOptions = {}): Promise<void> {
     if (options.codex) sources.push("codex");
     if (options.gemini) sources.push("gemini");
     if (options.cursor) sources.push("cursor");
+    if (options.amp) sources.push("amp");
+    if (options.droid) sources.push("droid");
+    includeCursor = sources.includes("cursor");
   }
 
+  // Filter out cursor from local sources (it's handled separately via sync)
+  const localSources = sources?.filter((s): s is Exclude<SourceType, "cursor"> => s !== "cursor");
+
   let data: TokenContributionData;
   try {
-    data = await generateGraphWithPricingAsync({
-      sources,
-      pricing: pricingEntries,
+    // Two-phase processing (same as TUI) for consistency:
+    // Phase 1: Parse local sources + sync cursor in parallel
+    const [localMessages, cursorSync] = await Promise.all([
+      parseLocalSourcesAsync({
+        sources: localSources,
+        since: options.since,
+        until: options.until,
+        year: options.year,
+      }),
+      includeCursor && loadCursorCredentials()
+        ? syncCursorCache()
+        : Promise.resolve({ synced: false, rows: 0 }),
+    ]);
+
+    // Phase 2: Finalize with pricing (combines local + cursor)
+    // Single subprocess call ensures consistent pricing for both report and graph
+    const { report, graph } = await finalizeReportAndGraphAsync({
+      localMessages,
+      includeCursor: includeCursor && cursorSync.synced,
       since: options.since,
       until: options.until,
       year: options.year,
     });
+
+    // Use graph structure for submission, report's cost for display
+    data = graph;
+    data.summary.totalCost = report.totalCost;
   } catch (error) {
     console.error(pc.red(`\n  Error generating data: ${(error as Error).message}\n`));
     process.exit(1);

package/src/tui/App.tsx

@@ -162,8 +162,12 @@ export function App(props: AppProps) {
   };
 
   const handleSortChange = (sort: SortType) => {
-    setSortBy(sort);
-    setSortDesc(true);
+    if (sortBy() === sort) {
+      setSortDesc(!sortDesc());
+    } else {
+      setSortBy(sort);
+      setSortDesc(true);
+    }
   };
 
   useKeyboard((key) => {
@@ -216,8 +220,7 @@ export function App(props: AppProps) {
     }
 
     if (key.name === "c" && !key.meta && !key.ctrl) {
-      setSortBy("cost");
-      setSortDesc(true);
+      handleSortChange("cost");
       return;
     }
 
@@ -263,8 +266,7 @@ export function App(props: AppProps) {
       return;
     }
     if (key.name === "t") {
-      setSortBy("tokens");
-      setSortDesc(true);
+      handleSortChange("tokens");
       return;
     }
 
@@ -278,6 +280,7 @@ export function App(props: AppProps) {
     if (key.name === "3") { handleSourceToggle("codex"); return; }
     if (key.name === "4") { handleSourceToggle("cursor"); return; }
     if (key.name === "5") { handleSourceToggle("gemini"); return; }
+    if (key.name === "6") { handleSourceToggle("amp"); return; }
 
     if (key.name === "up") {
       if (activeTab() === "overview") {

package/src/tui/components/DailyView.tsx

@@ -55,7 +55,26 @@ export function DailyView(props: DailyViewProps) {
     });
   });
 
-  const visibleEntries = createMemo(() => sortedEntries().slice(0, props.height - 3));
+  const visibleEntries = createMemo(() => {
+    const maxRows = Math.max(props.height - 3, 0);
+    return sortedEntries().slice(0, maxRows);
+  });
+
+  const formattedRows = createMemo(() => {
+    const dateColWidth = dateColumnWidths().column;
+    const narrow = isNarrowTerminal();
+    return visibleEntries().map((entry) => ({
+      entry,
+      dateColWidth,
+      narrow,
+      input: formatTokensCompact(entry.input),
+      output: formatTokensCompact(entry.output),
+      cacheRead: formatTokensCompact(entry.cacheRead),
+      cacheWrite: formatTokensCompact(entry.cacheWrite),
+      total: formatTokensCompact(entry.total),
+      cost: formatCostFull(entry.cost),
+    }));
+  });
 
   const sortArrow = () => (props.sortDesc ? "▼" : "▲");
   const dateHeader = () => "Date";
@@ -70,12 +89,11 @@ export function DailyView(props: DailyViewProps) {
     return `${("  " + dateHeader()).padEnd(dateColWidth)}${"Input".padStart(INPUT_COL_WIDTH)}${"Output".padStart(OUTPUT_COL_WIDTH)}${"C.Read".padStart(CACHE_READ_COL_WIDTH)}${"C.Write".padStart(CACHE_WRITE_COL_WIDTH)}${totalHeader().padStart(TOTAL_COL_WIDTH)}${costHeader().padStart(COST_COL_WIDTH)}`;
   };
 
-  const renderRow = (entry: typeof visibleEntries extends () => (infer T)[] ? T : never) => {
-    const dateColWidth = dateColumnWidths().column;
-    if (isNarrowTerminal()) {
-      return `${entry.date.padEnd(dateColWidth)}${formatTokensCompact(entry.total).padStart(TOTAL_COL_WIDTH)}`;
+  const renderRowData = (row: typeof formattedRows extends () => (infer T)[] ? T : never) => {
+    if (row.narrow) {
+      return `${row.entry.date.padEnd(row.dateColWidth)}${row.total.padStart(TOTAL_COL_WIDTH)}`;
     }
-    return `${entry.date.padEnd(dateColWidth)}${formatTokensCompact(entry.input).padStart(INPUT_COL_WIDTH)}${formatTokensCompact(entry.output).padStart(OUTPUT_COL_WIDTH)}${formatTokensCompact(entry.cacheRead).padStart(CACHE_READ_COL_WIDTH)}${formatTokensCompact(entry.cacheWrite).padStart(CACHE_WRITE_COL_WIDTH)}${formatTokensCompact(entry.total).padStart(TOTAL_COL_WIDTH)}`;
+    return `${row.entry.date.padEnd(row.dateColWidth)}${row.input.padStart(INPUT_COL_WIDTH)}${row.output.padStart(OUTPUT_COL_WIDTH)}${row.cacheRead.padStart(CACHE_READ_COL_WIDTH)}${row.cacheWrite.padStart(CACHE_WRITE_COL_WIDTH)}${row.total.padStart(TOTAL_COL_WIDTH)}`;
   };
 
   return (
@@ -86,24 +104,24 @@ export function DailyView(props: DailyViewProps) {
         </text>
       </box>
 
-      <For each={visibleEntries()}>
-        {(entry, i) => {
+      <For each={formattedRows()}>
+        {(row, i) => {
           const isActive = createMemo(() => i() === props.selectedIndex());
           const rowBg = createMemo(() => isActive() ? "blue" : (i() % 2 === 1 ? STRIPE_BG : undefined));
-          
+
           return (
             <box flexDirection="row">
               <text
                 bg={rowBg()}
                 fg={isActive() ? "white" : undefined}
               >
-                {renderRow(entry)}
+                {renderRowData(row)}
               </text>
               <text
                 fg="green"
                 bg={rowBg()}
               >
-                {formatCostFull(entry.cost).padStart(COST_COL_WIDTH)}
+                {row.cost.padStart(COST_COL_WIDTH)}
               </text>
             </box>
           );

package/src/tui/components/DateBreakdownPanel.tsx

@@ -1,6 +1,6 @@
 import { For, createMemo } from "solid-js";
 import type { DailyModelBreakdown } from "../types/index.js";
-import { getSourceColor } from "../utils/colors.js";
+import { getSourceColor, getSourceDisplayName } from "../utils/colors.js";
 import { formatTokens, formatCost } from "../utils/format.js";
 import { ModelRow } from "./ModelRow.js";
 
@@ -48,7 +48,7 @@ export function DateBreakdownPanel(props: DateBreakdownPanelProps) {
           {([source, models]) => (
             <box flexDirection="column">
               <box flexDirection="row" gap={1}>
-                <text fg={getSourceColor(source)} bold>{`● ${source.toUpperCase()}`}</text>
+                <text fg={getSourceColor(source)} bold>{`● ${getSourceDisplayName(source)}`}</text>
                 <text dim>{`(${models.length} model${models.length > 1 ? "s" : ""})`}</text>
               </box>
               <For each={models}>