refactor: optimize imports and improve usage analysis accuracy

- Move Tauri API imports to top level in ClipboardImagePaste and MediaSelector
- Optimize media utils by removing dynamic imports
- Enhance usage analysis with proper token calculation and project detection
- Add support for more model types in cost calculation
- Improve session parsing with better token data extraction

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: milisp

src/components/chat/ClipboardImagePaste.tsx

@@ -2,6 +2,7 @@ import React, { useEffect } from 'react';
 import { useChatInputStore } from '@/stores/chatInputStore';
 import { createMediaAttachment } from '@/utils/mediaUtils';
 import { writeFile, BaseDirectory } from '@tauri-apps/plugin-fs';
+import { appCacheDir } from '@tauri-apps/api/path';
 
 interface ClipboardImagePasteProps {
   children: React.ReactNode;
@@ -40,7 +41,6 @@ export const ClipboardImagePaste: React.FC<ClipboardImagePasteProps> = ({ childr
             await writeFile(tempPath, uint8Array, { baseDir: BaseDirectory.AppCache });
 
             // Get the full path for the media attachment
-            const { appCacheDir } = await import('@tauri-apps/api/path');
             const fullPath = `${await appCacheDir()}/temp/${fileName}`;
 
             // Create media attachment

src/components/chat/MediaSelector.tsx

@@ -11,6 +11,7 @@ import { useChatInputStore } from '@/stores/chatInputStore';
 import { isMediaFile, createMediaAttachment } from '@/utils/mediaUtils';
 import { open } from '@tauri-apps/plugin-dialog';
 import { writeFile, BaseDirectory } from '@tauri-apps/plugin-fs';
+import { appCacheDir } from '@tauri-apps/api/path';
 
 export const MediaSelector: React.FC = () => {
   const { addMediaAttachment } = useChatInputStore();
@@ -39,7 +40,6 @@ export const MediaSelector: React.FC = () => {
             await writeFile(tempPath, uint8Array, { baseDir: BaseDirectory.AppCache });
 
             // Get the full path for the media attachment
-            const { appCacheDir } = await import('@tauri-apps/api/path');
             const fullPath = `${await appCacheDir()}/temp/${fileName}`;
 
             // Create media attachment

src/utils/mediaUtils.ts

@@ -1,4 +1,5 @@
 import { MediaAttachment } from '@/types/chat';
+import { readFile } from '@tauri-apps/plugin-fs';
 
 // Supported image formats
 export const IMAGE_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp', '.svg'];
@@ -94,14 +95,12 @@ export const createMediaAttachment = async (filePath: string): Promise<MediaAtta
  */
 export const readFileAsBase64 = async (filePath: string): Promise<string> => {
   try {
-    // Dynamic import of Tauri API - use plugin-fs for Tauri v2
-    const fs = await import('@tauri-apps/plugin-fs');
-    const bytes = await fs.readFile(filePath);
+    const bytes = await readFile(filePath);
     const base64 = btoa(String.fromCharCode(...new Uint8Array(bytes)));
     const mimeType = getMimeType(filePath);
     return `data:${mimeType};base64,${base64}`;
   } catch (error) {
     console.error('Failed to read file as base64:', error);
     throw error;
   }
-};
+};

src/utils/usageAnalysis.ts

@@ -8,6 +8,12 @@ export interface TokenUsage {
   total_tokens: number;
 }
 
+// Helper function to calculate blended total like the CLI does
+function getBlendedTotal(usage: TokenUsage): number {
+  const nonCachedInput = usage.input_tokens - (usage.cached_input_tokens || 0);
+  return nonCachedInput + usage.output_tokens;
+}
+
 export interface SessionData {
   id: string;
   timestamp: string;
@@ -47,21 +53,27 @@ export interface UsageSummary {
 
 // Cost per million tokens (estimated based on common model pricing)
 const MODEL_COSTS: Record<string, { input: number; output: number; cache_write: number; cache_read: number }> = {
-  'gpt-5-high': { input: 15, output: 75, cache_write: 18.75, cache_read: 1.5 },
-  'gpt-5': { input: 3, output: 15, cache_write: 3.75, cache_read: 0.3 },
-  'gpt-5-mini': { input: 0.25, output: 1.25, cache_write: 0.3, cache_read: 0.03 },
+  'claude-3-5-sonnet-20241022': { input: 3, output: 15, cache_write: 3.75, cache_read: 0.3 },
+  'claude-3-5-haiku-20241022': { input: 0.8, output: 4, cache_write: 1, cache_read: 0.08 },
+  'claude-3-opus-20240229': { input: 15, output: 75, cache_write: 18.75, cache_read: 1.5 },
+  'gemini-2.5-flash-lite': { input: 0.075, output: 0.3, cache_write: 0.01875, cache_read: 0.00188 },
+  'gemini-2.5-flash': { input: 0.075, output: 0.3, cache_write: 0.01875, cache_read: 0.00188 },
+  'gpt-5': { input: 2.5, output: 10, cache_write: 1.25, cache_read: 0.125 },
+  'gpt-4o': { input: 2.5, output: 10, cache_write: 1.25, cache_read: 0.125 },
   'gpt-4': { input: 30, output: 60, cache_write: 30, cache_read: 3 },
   'gpt-3.5-turbo': { input: 0.5, output: 1.5, cache_write: 0.5, cache_read: 0.05 },
   'llama3.2': { input: 0, output: 0, cache_write: 0, cache_read: 0 }, // OSS model
+  'mistral': { input: 0, output: 0, cache_write: 0, cache_read: 0 }, // OSS model
 };
 
 function calculateTokenCost(usage: TokenUsage, model: string): number {
   const costs = MODEL_COSTS[model] || MODEL_COSTS['claude-3-5-sonnet-20241022']; // Default to Sonnet
 
-  const inputCost = (usage.input_tokens / 1_000_000) * costs.input;
+  const nonCachedInput = usage.input_tokens - (usage.cached_input_tokens || 0);
+  const inputCost = (nonCachedInput / 1_000_000) * costs.input;
   const outputCost = (usage.output_tokens / 1_000_000) * costs.output;
   const cacheWriteCost = ((usage.cached_input_tokens || 0) / 1_000_000) * costs.cache_write;
-  const cacheReadCost = 0; // Assuming cache read is included in input tokens
+  const cacheReadCost = 0; // Cache reads are typically much cheaper
 
   return inputCost + outputCost + cacheWriteCost + cacheReadCost;
 }
@@ -100,23 +112,49 @@ export async function parseSessionFile(filePath: string): Promise<SessionMetrics
     let totalInputTokens = 0;
     let totalOutputTokens = 0;
     let totalCacheTokens = 0;
-    let model = 'claude-3-5-sonnet-20241022'; // Default
+    let model = 'gpt-5'; // Default based on config
 
     // Count messages as a proxy for usage when actual token data is not available
     let messageCount = 0;
     let hasUserMessages = false;
     let hasAssistantMessages = false;
+    let projectFromCwd = '';
 
     for (const line of lines) {
       try {
         const event = JSON.parse(line);
 
-        // Look for token count events (actual usage data)
-        if (event.msg?.type === 'token_count' && event.msg.usage) {
-          const usage: TokenUsage = event.msg.usage;
-          totalInputTokens += usage.input_tokens;
-          totalOutputTokens += usage.output_tokens;
-          totalCacheTokens += usage.cached_input_tokens || 0;
+        // Look for token count events - handle various event structures from codex CLI
+        // Based on the CLI source, TokenCount events come as EventMsg::TokenCount(TokenUsage)
+        if (event.msg && typeof event.msg === 'object') {
+          // Direct TokenUsage structure (EventMsg::TokenCount)
+          if ('input_tokens' in event.msg || 'output_tokens' in event.msg || 'total_tokens' in event.msg) {
+            const usage = event.msg as TokenUsage;
+            // Use cumulative values as they represent session totals
+            if (usage.input_tokens !== undefined) {
+              totalInputTokens = Math.max(totalInputTokens, usage.input_tokens);
+            }
+            if (usage.output_tokens !== undefined) {
+              totalOutputTokens = Math.max(totalOutputTokens, usage.output_tokens);
+            }
+            if (usage.cached_input_tokens !== undefined) {
+              totalCacheTokens = Math.max(totalCacheTokens, usage.cached_input_tokens);
+            }
+          }
+          
+          // Nested structure with type field
+          if (event.msg.type === 'token_count' && event.msg.usage) {
+            const usage: TokenUsage = event.msg.usage;
+            if (usage.input_tokens !== undefined) {
+              totalInputTokens = Math.max(totalInputTokens, usage.input_tokens);
+            }
+            if (usage.output_tokens !== undefined) {
+              totalOutputTokens = Math.max(totalOutputTokens, usage.output_tokens);
+            }
+            if (usage.cached_input_tokens !== undefined) {
+              totalCacheTokens = Math.max(totalCacheTokens, usage.cached_input_tokens);
+            }
+          }
         }
 
         // Look for messages to estimate usage when no token data available
@@ -129,57 +167,69 @@ export async function parseSessionFile(filePath: string): Promise<SessionMetrics
           }
         }
 
-        // Extract model info from various sources
+        // Extract project info from environment context (cwd)
+        if (event.content && Array.isArray(event.content)) {
+          for (const content of event.content) {
+            if (content.type === 'input_text' && content.text.includes('<cwd>')) {
+              const cwdMatch = content.text.match(/<cwd>([^<]+)<\/cwd>/);
+              if (cwdMatch && cwdMatch[1]) {
+                projectFromCwd = cwdMatch[1].split('/').pop() || cwdMatch[1];
+              }
+            }
+          }
+        }
+        
+        // Extract model info from various sources - default to what's actually configured
         if (event.msg?.model) {
           model = event.msg.model;
         }
         if (event.model) {
           model = event.model;
         }
-        
-        // Check for git repo info to determine if it's Claude Code usage
-        if (event.git?.repository_url && event.git.repository_url.includes('codexia')) {
-          model = 'gpt-5-high'; // Likely using Claude 4 for development
-        }
       } catch {
         // Skip invalid JSON lines
       }
     }
 
-    // If no actual token data, estimate based on messages
-    if (totalInputTokens === 0 && totalOutputTokens === 0 && hasUserMessages && hasAssistantMessages) {
-      // Rough estimation: user input ~100 tokens, assistant response ~300 tokens per exchange
+    // If no actual token data, estimate based on messages for meaningful sessions
+    if (totalInputTokens === 0 && totalOutputTokens === 0 && hasUserMessages && hasAssistantMessages && messageCount >= 2) {
+      // Conservative estimation based on typical coding conversations
       const estimatedExchanges = Math.ceil(messageCount / 2);
-      totalInputTokens = estimatedExchanges * 150; // Average input
-      totalOutputTokens = estimatedExchanges * 400; // Average output
-      totalCacheTokens = estimatedExchanges * 50; // Some caching
+      totalInputTokens = estimatedExchanges * 200; // Average user input with context
+      totalOutputTokens = estimatedExchanges * 600; // Average assistant response with code
+      totalCacheTokens = estimatedExchanges * 100; // Context caching
     }
 
-    const totalTokens = totalInputTokens + totalOutputTokens;
+    // Calculate total tokens using the same logic as CLI (blended total)
+    const mockUsage: TokenUsage = {
+      input_tokens: totalInputTokens,
+      output_tokens: totalOutputTokens,
+      cached_input_tokens: totalCacheTokens,
+      total_tokens: totalInputTokens + totalOutputTokens,
+    };
+    const totalTokens = getBlendedTotal(mockUsage);
 
     // Skip sessions with no meaningful activity
     if (totalTokens === 0 && messageCount < 2) {
       return null;
     }
 
-    // Extract project path from git repo or session path
-    let projectPath = sessionData.git?.repository_url || filePath;
-    if (projectPath.includes('/')) {
-      projectPath = projectPath.split('/').pop() || projectPath;
-    }
-    if (projectPath.includes('.git')) {
-      projectPath = projectPath.replace('.git', '');
-    }
-    if (projectPath.startsWith('git@github.com:')) {
-      projectPath = projectPath.replace('git@github.com:', '').replace('.git', '');
+    // Extract project path - prefer cwd from environment context, fallback to filename
+    let projectPath = projectFromCwd;
+    if (!projectPath) {
+      // Fallback to extracting from file path
+      projectPath = filePath.split('/').pop() || filePath;
+      if (projectPath.includes('rollout-') && projectPath.endsWith('.jsonl')) {
+        // For rollout files, use the directory name instead
+        const pathParts = filePath.split('/');
+        if (pathParts.length > 1) {
+          // Try to get a meaningful project name from the path or use generic name
+          projectPath = 'Unknown Session';
+        }
+      }
     }
 
-    const estimatedCost = calculateTokenCost({
-      input_tokens: totalInputTokens,
-      output_tokens: totalOutputTokens,
-      cached_input_tokens: totalCacheTokens,
-      total_tokens: totalTokens,
-    }, model);
+    const estimatedCost = calculateTokenCost(mockUsage, model);
 
     return {
       sessionId: sessionData.id,
@@ -292,4 +342,4 @@ export async function calculateUsageSummary(): Promise<UsageSummary> {
     projectBreakdown,
     timelineData,
   };
-}
+}