agentlytics 0.1.5 → 0.1.7

package/README.md

@@ -179,7 +179,7 @@ All endpoints accept optional `editor` filter. See **[API.md](API.md)** for full
 - [ ] **LLM-powered insights** — Use an LLM to analyze session patterns, generate summaries, detect coding habits, and surface actionable recommendations
 - [ ] **Linux & Windows support** — Adapt editor paths for non-macOS platforms
 - [ ] **Export & reports** — PDF/CSV export of analytics and session data
-- [ ] **Cost tracking** — Estimate API costs per editor/model based on token usage
+- [x] **Cost tracking** — Estimate API costs per editor/model based on token usage
 
 ## Contributions Needed
 

package/cache.js

@@ -3,9 +3,11 @@ const path = require('path');
 const os = require('os');
 const fs = require('fs');
 const { getAllChats, getMessages, findChat: findChatRaw, resetCaches } = require('./editors');
+const { calculateCost, getModelPricing, normalizeModelName } = require('./pricing');
 
 const CACHE_DIR = path.join(os.homedir(), '.agentlytics');
 const CACHE_DB = path.join(CACHE_DIR, 'cache.db');
+const SCHEMA_VERSION = 4; // bump this when schema changes to auto-revalidate
 
 let db = null;
 
@@ -15,6 +17,28 @@ let db = null;
 
 function initDb() {
   if (!fs.existsSync(CACHE_DIR)) fs.mkdirSync(CACHE_DIR, { recursive: true });
+
+  // Check schema version; wipe DB on mismatch
+  if (fs.existsSync(CACHE_DB)) {
+    try {
+      const tmp = new Database(CACHE_DB, { readonly: true });
+      const row = tmp.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get();
+      tmp.close();
+      if (!row || parseInt(row.value) !== SCHEMA_VERSION) {
+        for (const suffix of ['', '-wal', '-shm']) {
+          const f = CACHE_DB + suffix;
+          if (fs.existsSync(f)) fs.unlinkSync(f);
+        }
+      }
+    } catch {
+      // Corrupt or unreadable DB — wipe it
+      for (const suffix of ['', '-wal', '-shm']) {
+        const f = CACHE_DB + suffix;
+        if (fs.existsSync(f)) fs.unlinkSync(f);
+      }
+    }
+  }
+
   db = new Database(CACHE_DB);
   db.pragma('journal_mode = WAL');
   db.pragma('synchronous = NORMAL');
@@ -86,6 +110,9 @@ function initDb() {
     CREATE INDEX IF NOT EXISTS idx_tool_calls_name ON tool_calls(tool_name);
     CREATE INDEX IF NOT EXISTS idx_tool_calls_chat ON tool_calls(chat_id);
   `);
+
+  // Store schema version so future runs can detect mismatches
+  db.prepare('INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)').run('schema_version', SCHEMA_VERSION.toString());
 }
 
 // ============================================================
@@ -266,9 +293,23 @@ function scanAll(onProgress, opts = {}) {
 // Query helpers (used by server.js)
 // ============================================================
 
+// Returns { sql, params } for excluding hidden folders
+function hiddenFolderFilter(opts, colName = 'folder') {
+  if (!opts.hiddenFolders || opts.hiddenFolders.length === 0) return { sql: '', params: [] };
+  const placeholders = opts.hiddenFolders.map(() => '?').join(',');
+  return { sql: ` AND (${colName} IS NULL OR ${colName} NOT IN (${placeholders}))`, params: [...opts.hiddenFolders] };
+}
+
 function getCachedChats(opts = {}) {
-  let sql = 'SELECT c.*, cs.models AS _models FROM chats c LEFT JOIN chat_stats cs ON cs.chat_id = c.id WHERE 1=1';
+  let sql = `SELECT c.*,
+    cs.models AS _models,
+    cs.total_input_tokens AS _inTok, cs.total_output_tokens AS _outTok,
+    cs.total_cache_read AS _cacheR, cs.total_cache_write AS _cacheW,
+    cs.total_user_chars AS _uChars, cs.total_assistant_chars AS _aChars
+    FROM chats c LEFT JOIN chat_stats cs ON cs.chat_id = c.id WHERE 1=1`;
   const params = [];
+  const hf = hiddenFolderFilter(opts, 'c.folder');
+  if (hf.sql) { sql += hf.sql; params.push(...hf.params); }
   if (opts.editor) { sql += ' AND c.source LIKE ?'; params.push(`%${opts.editor}%`); }
   if (opts.folder) { sql += ' AND c.folder LIKE ?'; params.push(`%${opts.folder}%`); }
   if (opts.named !== false) { sql += ' AND (c.name IS NOT NULL OR c.bubble_count > 0)'; }
@@ -288,7 +329,14 @@ function getCachedChats(opts = {}) {
         r.top_model = Object.entries(freq).sort((a, b) => b[1] - a[1])[0][0];
       }
     } catch {}
-    delete r._models;
+    // Per-session cost estimate
+    let inTok = r._inTok || 0, outTok = r._outTok || 0;
+    if (inTok === 0 && outTok === 0 && ((r._uChars || 0) > 0 || (r._aChars || 0) > 0)) {
+      inTok = Math.round((r._uChars || 0) / 4);
+      outTok = Math.round((r._aChars || 0) / 4);
+    }
+    r.cost = r.top_model ? (calculateCost(r.top_model, inTok, outTok, r._cacheR || 0, r._cacheW || 0) || 0) : 0;
+    delete r._models; delete r._inTok; delete r._outTok; delete r._cacheR; delete r._cacheW; delete r._uChars; delete r._aChars;
   }
   return rows;
 }
@@ -296,6 +344,8 @@ function getCachedChats(opts = {}) {
 function countCachedChats(opts = {}) {
   let sql = 'SELECT COUNT(*) as cnt FROM chats WHERE 1=1';
   const params = [];
+  const hf = hiddenFolderFilter(opts);
+  if (hf.sql) { sql += hf.sql; params.push(...hf.params); }
   if (opts.editor) { sql += ' AND source LIKE ?'; params.push(`%${opts.editor}%`); }
   if (opts.folder) { sql += ' AND folder LIKE ?'; params.push(`%${opts.folder}%`); }
   if (opts.named !== false) { sql += ' AND (name IS NOT NULL OR bubble_count > 0)'; }
@@ -308,6 +358,8 @@ function getCachedOverview(opts = {}) {
   // Build conditions dynamically to support editor + date range filters
   const conditions = [];
   const params = [];
+  const hf = hiddenFolderFilter(opts);
+  if (hf.sql) { conditions.push(hf.sql.replace(' AND ', '')); params.push(...hf.params); }
   if (opts.editor) { conditions.push('source = ?'); params.push(opts.editor); }
   if (opts.dateFrom) { conditions.push('COALESCE(last_updated_at, created_at) >= ?'); params.push(opts.dateFrom); }
   if (opts.dateTo) { conditions.push('COALESCE(last_updated_at, created_at) <= ?'); params.push(opts.dateTo); }
@@ -372,6 +424,8 @@ function getCachedOverview(opts = {}) {
 function getCachedDailyActivity(opts = {}) {
   const conditions = [];
   const params = [];
+  const hf = hiddenFolderFilter(opts);
+  if (hf.sql) { conditions.push(hf.sql.replace(' AND ', '')); params.push(...hf.params); }
   if (opts.editor) { conditions.push('source = ?'); params.push(opts.editor); }
   if (opts.dateFrom) { conditions.push('COALESCE(last_updated_at, created_at) >= ?'); params.push(opts.dateFrom); }
   if (opts.dateTo) { conditions.push('COALESCE(last_updated_at, created_at) <= ?'); params.push(opts.dateTo); }
@@ -402,6 +456,8 @@ function getCachedDailyActivity(opts = {}) {
 function getCachedDeepAnalytics(opts = {}) {
   let sql = 'SELECT cs.* FROM chat_stats cs JOIN chats c ON cs.chat_id = c.id WHERE 1=1';
   const params = [];
+  const hf = hiddenFolderFilter(opts, 'c.folder');
+  if (hf.sql) { sql += hf.sql; params.push(...hf.params); }
   if (opts.editor) { sql += ' AND c.source LIKE ?'; params.push(`%${opts.editor}%`); }
   if (opts.folder) { sql += ' AND c.folder = ?'; params.push(opts.folder); }
   if (opts.dateFrom) { sql += ' AND COALESCE(c.last_updated_at, c.created_at) >= ?'; params.push(opts.dateFrom); }
@@ -432,15 +488,23 @@ function getCachedDeepAnalytics(opts = {}) {
     } catch {}
     try {
       const models = JSON.parse(r.models);
-      for (const m of models) { modelFreq[m] = (modelFreq[m] || 0) + 1; }
+      for (const m of models) { const k = normalizeModelName(m) || m; modelFreq[k] = (modelFreq[k] || 0) + 1; }
     } catch {}
   }
 
+  // Estimate tokens from chars when no token data available
+  let tokensEstimated = false;
+  if (totalInputTokens === 0 && totalOutputTokens === 0 && (totalUserChars > 0 || totalAssistantChars > 0)) {
+    totalInputTokens = Math.round(totalUserChars / 4);
+    totalOutputTokens = Math.round(totalAssistantChars / 4);
+    tokensEstimated = true;
+  }
+
   return {
     analyzedChats: rows.length,
     totalMessages, totalToolCalls,
     totalUserChars, totalAssistantChars,
-    totalInputTokens, totalOutputTokens,
+    totalInputTokens, totalOutputTokens, tokensEstimated,
     totalCacheRead, totalCacheWrite,
     topTools: Object.entries(toolFreq).sort((a, b) => b[1] - a[1]).slice(0, 30).map(([name, count]) => ({ name, count })),
     topModels: Object.entries(modelFreq).sort((a, b) => b[1] - a[1]).slice(0, 20).map(([name, count]) => ({ name, count })),
@@ -495,6 +559,10 @@ function getCachedProjects(opts = {}) {
   // Build date filter
   let dateFilter = '';
   const dateParams = [];
+  if (!opts.includeHidden) {
+    const hf = hiddenFolderFilter(opts);
+    if (hf.sql) { dateFilter += hf.sql; dateParams.push(...hf.params); }
+  }
   if (opts.dateFrom) { dateFilter += ' AND COALESCE(last_updated_at, created_at) >= ?'; dateParams.push(opts.dateFrom); }
   if (opts.dateTo) { dateFilter += ' AND COALESCE(last_updated_at, created_at) <= ?'; dateParams.push(opts.dateTo); }
 
@@ -543,10 +611,18 @@ function getCachedProjects(opts = {}) {
       totalAssistantChars += s.total_assistant_chars;
       totalCacheRead += s.total_cache_read;
       totalCacheWrite += s.total_cache_write;
-      try { for (const m of JSON.parse(s.models)) { modelFreq[m] = (modelFreq[m] || 0) + 1; } } catch {}
+      try { for (const m of JSON.parse(s.models)) { const k = normalizeModelName(m) || m; modelFreq[k] = (modelFreq[k] || 0) + 1; } } catch {}
       try { for (const t of JSON.parse(s.tool_calls)) { toolFreq[t] = (toolFreq[t] || 0) + 1; totalToolCalls++; } } catch {}
     }
 
+    // Estimate tokens from chars when no token data available
+    let tokensEstimated = false;
+    if (totalInputTokens === 0 && totalOutputTokens === 0 && (totalUserChars > 0 || totalAssistantChars > 0)) {
+      totalInputTokens = Math.round(totalUserChars / 4);
+      totalOutputTokens = Math.round(totalAssistantChars / 4);
+      tokensEstimated = true;
+    }
+
     result.push({
       folder: proj.folder,
       name: proj.folder.split('/').pop(),
@@ -556,7 +632,7 @@ function getCachedProjects(opts = {}) {
       lastSeen: proj.lastSeen,
       totalMessages,
       totalInputTokens,
-      totalOutputTokens,
+      totalOutputTokens, tokensEstimated,
       totalUserChars,
       totalAssistantChars,
       totalToolCalls,
@@ -690,6 +766,8 @@ function getCachedDashboardStats(opts = {}) {
   // Build conditions dynamically to support editor + date range filters
   const conditions = [];
   const params = [];
+  const hf = hiddenFolderFilter(opts);
+  if (hf.sql) { conditions.push(hf.sql.replace(' AND ', '')); params.push(...hf.params); }
   if (opts.editor) { conditions.push('source = ?'); params.push(opts.editor); }
   if (opts.dateFrom) { conditions.push('COALESCE(last_updated_at, created_at) >= ?'); params.push(opts.dateFrom); }
   if (opts.dateTo) { conditions.push('COALESCE(last_updated_at, created_at) <= ?'); params.push(opts.dateTo); }
@@ -818,7 +896,7 @@ function getCachedDashboardStats(opts = {}) {
   `).all(...params);
   const modelFreq = {};
   for (const r of modelRows) {
-    try { for (const m of JSON.parse(r.models)) modelFreq[m] = (modelFreq[m] || 0) + 1; } catch {}
+    try { for (const m of JSON.parse(r.models)) { const k = normalizeModelName(m) || m; modelFreq[k] = (modelFreq[k] || 0) + 1; } } catch {}
   }
   const topModels = Object.entries(modelFreq).sort((a, b) => b[1] - a[1]).slice(0, 10);
 
@@ -833,18 +911,29 @@ function getCachedDashboardStats(opts = {}) {
   }
   const topTools = Object.entries(toolFreq).sort((a, b) => b[1] - a[1]).slice(0, 8);
 
+  // If no token data but chars exist, estimate tokens (~4 chars/token)
+  let inputTokens = tokenRow.input;
+  let outputTokens = tokenRow.output;
+  let tokensEstimated = false;
+  if (inputTokens === 0 && outputTokens === 0 && (tokenRow.userChars > 0 || tokenRow.assistantChars > 0)) {
+    inputTokens = Math.round(tokenRow.userChars / 4);
+    outputTokens = Math.round(tokenRow.assistantChars / 4);
+    tokensEstimated = true;
+  }
+
   return {
     hourly,
     weekdays,
     depthBuckets,
     tokens: {
-      input: tokenRow.input,
-      output: tokenRow.output,
+      input: inputTokens,
+      output: outputTokens,
       cacheRead: tokenRow.cacheRead,
       cacheWrite: tokenRow.cacheWrite,
       userChars: tokenRow.userChars,
       assistantChars: tokenRow.assistantChars,
       sessions: tokenRow.sessions,
+      estimated: tokensEstimated,
     },
     streaks: { current: currentStreak, longest: longestStreak, totalDays: streakRows.length },
     monthlyTrend: { months: Object.keys(monthEditors).sort(), sources: [...allSources], data: monthEditors },
@@ -855,6 +944,346 @@ function getCachedDashboardStats(opts = {}) {
   };
 }
 
+// ============================================================
+// Cost estimation
+// ============================================================
+
+function estimateCosts(whereClause = '', params = []) {
+  // Per-model token usage from messages table
+  const modelTokens = db.prepare(`
+    SELECT m.model, SUM(m.input_tokens) as input, SUM(m.output_tokens) as output
+    FROM messages m JOIN chats c ON m.chat_id = c.id
+    WHERE m.model IS NOT NULL AND (m.input_tokens > 0 OR m.output_tokens > 0)${whereClause}
+    GROUP BY m.model
+  `).all(...params);
+
+  // Orphaned tokens: messages with token data but NULL model.
+  // Attribute these to the session's dominant model from chat_stats.
+  const orphanRows = db.prepare(`
+    SELECT m.chat_id, SUM(m.input_tokens) as input, SUM(m.output_tokens) as output
+    FROM messages m JOIN chats c ON m.chat_id = c.id
+    WHERE m.model IS NULL AND (m.input_tokens > 0 OR m.output_tokens > 0)${whereClause}
+    GROUP BY m.chat_id
+  `).all(...params);
+
+  const orphanByModel = {};
+  for (const r of orphanRows) {
+    const stat = db.prepare('SELECT models FROM chat_stats WHERE chat_id = ?').get(r.chat_id);
+    if (!stat) continue;
+    let models;
+    try { models = JSON.parse(stat.models || '[]'); } catch { continue; }
+    if (models.length === 0) continue;
+    const freq = {};
+    for (const m of models) freq[m] = (freq[m] || 0) + 1;
+    const dominant = Object.entries(freq).sort((a, b) => b[1] - a[1])[0][0];
+    if (!orphanByModel[dominant]) orphanByModel[dominant] = { input: 0, output: 0 };
+    orphanByModel[dominant].input += r.input || 0;
+    orphanByModel[dominant].output += r.output || 0;
+  }
+
+  // Cache tokens per session with dominant model
+  const cacheRows = db.prepare(`
+    SELECT cs.total_cache_read, cs.total_cache_write, cs.models
+    FROM chat_stats cs JOIN chats c ON cs.chat_id = c.id
+    WHERE (cs.total_cache_read > 0 OR cs.total_cache_write > 0)${whereClause}
+  `).all(...params);
+
+  // Aggregate cache tokens by dominant model
+  const cacheByModel = {};
+  for (const r of cacheRows) {
+    let models;
+    try { models = JSON.parse(r.models || '[]'); } catch { continue; }
+    if (models.length === 0) continue;
+    const freq = {};
+    for (const m of models) freq[m] = (freq[m] || 0) + 1;
+    const dominant = Object.entries(freq).sort((a, b) => b[1] - a[1])[0][0];
+    if (!cacheByModel[dominant]) cacheByModel[dominant] = { cacheRead: 0, cacheWrite: 0 };
+    cacheByModel[dominant].cacheRead += r.total_cache_read;
+    cacheByModel[dominant].cacheWrite += r.total_cache_write;
+  }
+
+  // Char-based estimation: sessions with models + chars but zero tokens.
+  // Estimate ~4 chars per token (user chars → input, assistant chars → output).
+  const CHARS_PER_TOKEN = 4;
+  const charRows = db.prepare(`
+    SELECT cs.models, cs.total_user_chars as userChars, cs.total_assistant_chars as asstChars
+    FROM chat_stats cs JOIN chats c ON cs.chat_id = c.id
+    WHERE cs.models != '[]' AND cs.total_input_tokens = 0 AND cs.total_output_tokens = 0
+      AND (cs.total_user_chars > 0 OR cs.total_assistant_chars > 0)${whereClause}
+  `).all(...params);
+
+  for (const r of charRows) {
+    let models;
+    try { models = JSON.parse(r.models || '[]'); } catch { continue; }
+    if (models.length === 0) continue;
+    const freq = {};
+    for (const m of models) freq[m] = (freq[m] || 0) + 1;
+    const dominant = Object.entries(freq).sort((a, b) => b[1] - a[1])[0][0];
+    if (!orphanByModel[dominant]) orphanByModel[dominant] = { input: 0, output: 0 };
+    orphanByModel[dominant].input += Math.round((r.userChars || 0) / CHARS_PER_TOKEN);
+    orphanByModel[dominant].output += Math.round((r.asstChars || 0) / CHARS_PER_TOKEN);
+  }
+
+  // Sessions with token totals but empty models (e.g. Cursor composer chats).
+  // Attribute to the dominant model from same editor source.
+  const unmodeledRows = db.prepare(`
+    SELECT c.source, cs.total_input_tokens as input, cs.total_output_tokens as output,
+           cs.total_cache_read as cacheRead, cs.total_cache_write as cacheWrite
+    FROM chat_stats cs JOIN chats c ON cs.chat_id = c.id
+    WHERE cs.models = '[]' AND (cs.total_input_tokens > 0 OR cs.total_output_tokens > 0)${whereClause}
+  `).all(...params);
+
+  if (unmodeledRows.length > 0) {
+    // Find dominant model per source from sessions that DO have models
+    const sourceModelFreq = {};
+    const allSessions = db.prepare(`
+      SELECT c.source, cs.models FROM chat_stats cs JOIN chats c ON cs.chat_id = c.id
+      WHERE cs.models != '[]'${whereClause}
+    `).all(...params);
+    for (const s of allSessions) {
+      let models;
+      try { models = JSON.parse(s.models || '[]'); } catch { continue; }
+      if (!sourceModelFreq[s.source]) sourceModelFreq[s.source] = {};
+      for (const m of models) sourceModelFreq[s.source][m] = (sourceModelFreq[s.source][m] || 0) + 1;
+    }
+    // Global fallback: dominant model across all sources
+    const globalFreq = {};
+    for (const sf of Object.values(sourceModelFreq)) {
+      for (const [m, c] of Object.entries(sf)) globalFreq[m] = (globalFreq[m] || 0) + c;
+    }
+    const globalDominant = Object.entries(globalFreq).sort((a, b) => b[1] - a[1])[0]?.[0];
+
+    for (const r of unmodeledRows) {
+      const sf = sourceModelFreq[r.source];
+      const dominant = sf
+        ? Object.entries(sf).sort((a, b) => b[1] - a[1])[0]?.[0]
+        : globalDominant;
+      if (!dominant) continue;
+      if (!orphanByModel[dominant]) orphanByModel[dominant] = { input: 0, output: 0 };
+      orphanByModel[dominant].input += r.input || 0;
+      orphanByModel[dominant].output += r.output || 0;
+      // Also merge cache data
+      if (!cacheByModel[dominant]) cacheByModel[dominant] = { cacheRead: 0, cacheWrite: 0 };
+      cacheByModel[dominant].cacheRead += r.cacheRead || 0;
+      cacheByModel[dominant].cacheWrite += r.cacheWrite || 0;
+    }
+  }
+
+  // Merge modelTokens + orphanByModel into a unified map, normalizing keys
+  const tokenMap = {};
+  const addTokens = (rawModel, input, output) => {
+    const key = normalizeModelName(rawModel) || rawModel;
+    if (!tokenMap[key]) tokenMap[key] = { input: 0, output: 0 };
+    tokenMap[key].input += input || 0;
+    tokenMap[key].output += output || 0;
+  };
+  for (const row of modelTokens) addTokens(row.model, row.input, row.output);
+  for (const [model, tok] of Object.entries(orphanByModel)) addTokens(model, tok.input, tok.output);
+
+  // Normalize cacheByModel keys
+  const normCache = {};
+  for (const [model, cache] of Object.entries(cacheByModel)) {
+    const key = normalizeModelName(model) || model;
+    if (!normCache[key]) normCache[key] = { cacheRead: 0, cacheWrite: 0 };
+    normCache[key].cacheRead += cache.cacheRead;
+    normCache[key].cacheWrite += cache.cacheWrite;
+  }
+
+  let totalCost = 0;
+  let knownCost = 0;
+  let unknownModels = [];
+  const byModel = [];
+
+  for (const [model, tok] of Object.entries(tokenMap)) {
+    const cache = normCache[model] || { cacheRead: 0, cacheWrite: 0 };
+    const cost = calculateCost(model, tok.input, tok.output, cache.cacheRead, cache.cacheWrite);
+    if (cost !== null) {
+      knownCost += cost;
+      totalCost += cost;
+      byModel.push({ model, inputTokens: tok.input, outputTokens: tok.output, cacheRead: cache.cacheRead, cacheWrite: cache.cacheWrite, cost });
+    } else {
+      unknownModels.push(model);
+    }
+  }
+
+  // Handle cache tokens for models that had cache but no message-level tokens
+  for (const [model, cache] of Object.entries(normCache)) {
+    if (!tokenMap[model]) {
+      const cost = calculateCost(model, 0, 0, cache.cacheRead, cache.cacheWrite);
+      if (cost !== null) {
+        totalCost += cost;
+        byModel.push({ model, inputTokens: 0, outputTokens: 0, cacheRead: cache.cacheRead, cacheWrite: cache.cacheWrite, cost });
+      }
+    }
+  }
+
+  byModel.sort((a, b) => b.cost - a.cost);
+  unknownModels = [...new Set(unknownModels)];
+
+  return { totalCost, byModel, unknownModels };
+}
+
+function getCostBreakdown(opts = {}) {
+  let whereClause = '';
+  const params = [];
+  const hf = hiddenFolderFilter(opts, 'c.folder');
+  if (hf.sql) { whereClause += hf.sql; params.push(...hf.params); }
+  if (opts.editor) { whereClause += ' AND c.source LIKE ?'; params.push(`%${opts.editor}%`); }
+  if (opts.folder) { whereClause += ' AND c.folder = ?'; params.push(opts.folder); }
+  if (opts.dateFrom) { whereClause += ' AND COALESCE(c.last_updated_at, c.created_at) >= ?'; params.push(opts.dateFrom); }
+  if (opts.dateTo) { whereClause += ' AND COALESCE(c.last_updated_at, c.created_at) <= ?'; params.push(opts.dateTo); }
+  if (opts.chatId) { whereClause += ' AND c.id = ?'; params.push(opts.chatId); }
+  return estimateCosts(whereClause, params);
+}
+
+function getCostAnalytics(opts = {}) {
+  const conditions = [];
+  const params = [];
+  const hf = hiddenFolderFilter(opts, 'c.folder');
+  if (hf.sql) { conditions.push(hf.sql.replace(' AND ', '')); params.push(...hf.params); }
+  if (opts.editor) { conditions.push('c.source LIKE ?'); params.push(`%${opts.editor}%`); }
+  if (opts.dateFrom) { conditions.push('COALESCE(c.last_updated_at, c.created_at) >= ?'); params.push(opts.dateFrom); }
+  if (opts.dateTo) { conditions.push('COALESCE(c.last_updated_at, c.created_at) <= ?'); params.push(opts.dateTo); }
+  const whereAnd = conditions.length > 0 ? ' AND ' + conditions.join(' AND ') : '';
+
+  // Overall cost breakdown by model
+  const overall = getCostBreakdown(opts);
+
+  // Cost by editor: get costs per source
+  const editorRows = db.prepare(`
+    SELECT DISTINCT c.source FROM chats c WHERE c.source IS NOT NULL${whereAnd}
+  `).all(...params);
+  const byEditor = [];
+  for (const { source } of editorRows) {
+    const editorOpts = { ...opts, editor: source };
+    const ec = getCostBreakdown(editorOpts);
+    if (ec.totalCost > 0) {
+      byEditor.push({ editor: source, cost: ec.totalCost, models: ec.byModel.length });
+    }
+  }
+  byEditor.sort((a, b) => b.cost - a.cost);
+
+  // Cost by project (top 20)
+  const projectRows = db.prepare(`
+    SELECT c.folder, COUNT(*) as sessions FROM chats c
+    WHERE c.folder IS NOT NULL${whereAnd}
+    GROUP BY c.folder ORDER BY sessions DESC LIMIT 30
+  `).all(...params);
+  const byProject = [];
+  for (const { folder } of projectRows) {
+    const pc = getCostBreakdown({ ...opts, folder });
+    if (pc.totalCost > 0) {
+      byProject.push({ folder, name: folder.split('/').pop(), cost: pc.totalCost });
+    }
+  }
+  byProject.sort((a, b) => b.cost - a.cost);
+
+  // Monthly trend
+  const monthRows = db.prepare(`
+    SELECT
+      substr(date(COALESCE(c.last_updated_at, c.created_at)/1000, 'unixepoch'), 1, 7) as month,
+      c.id, c.source,
+      cs.models AS _models,
+      cs.total_input_tokens AS inTok, cs.total_output_tokens AS outTok,
+      cs.total_cache_read AS cacheR, cs.total_cache_write AS cacheW,
+      cs.total_user_chars AS uChars, cs.total_assistant_chars AS aChars
+    FROM chats c LEFT JOIN chat_stats cs ON cs.chat_id = c.id
+    WHERE (c.last_updated_at IS NOT NULL OR c.created_at IS NOT NULL)${whereAnd}
+    ORDER BY month
+  `).all(...params);
+  const monthCosts = {};
+  for (const r of monthRows) {
+    if (!r.month) continue;
+    let topModel = null;
+    try {
+      const models = JSON.parse(r._models || '[]');
+      if (models.length > 0) {
+        const freq = {};
+        for (const m of models) freq[m] = (freq[m] || 0) + 1;
+        topModel = Object.entries(freq).sort((a, b) => b[1] - a[1])[0][0];
+      }
+    } catch {}
+    if (!topModel) continue;
+    let inTok = r.inTok || 0, outTok = r.outTok || 0;
+    if (inTok === 0 && outTok === 0 && ((r.uChars || 0) > 0 || (r.aChars || 0) > 0)) {
+      inTok = Math.round((r.uChars || 0) / 4);
+      outTok = Math.round((r.aChars || 0) / 4);
+    }
+    const cost = calculateCost(topModel, inTok, outTok, r.cacheR || 0, r.cacheW || 0) || 0;
+    if (!monthCosts[r.month]) monthCosts[r.month] = { cost: 0, sessions: 0 };
+    monthCosts[r.month].cost += cost;
+    monthCosts[r.month].sessions++;
+  }
+  const monthly = Object.entries(monthCosts).sort((a, b) => a[0].localeCompare(b[0]))
+    .map(([month, d]) => ({ month, cost: Math.round(d.cost * 100) / 100, sessions: d.sessions }));
+
+  // Top expensive sessions
+  const sessionRows = db.prepare(`
+    SELECT c.id, c.source, c.name, c.folder, c.last_updated_at, c.created_at,
+      cs.models AS _models,
+      cs.total_input_tokens AS inTok, cs.total_output_tokens AS outTok,
+      cs.total_cache_read AS cacheR, cs.total_cache_write AS cacheW,
+      cs.total_user_chars AS uChars, cs.total_assistant_chars AS aChars,
+      cs.total_messages AS msgs
+    FROM chats c LEFT JOIN chat_stats cs ON cs.chat_id = c.id
+    WHERE 1=1${whereAnd}
+  `).all(...params);
+  const sessionCosts = [];
+  for (const r of sessionRows) {
+    let topModel = null;
+    try {
+      const models = JSON.parse(r._models || '[]');
+      if (models.length > 0) {
+        const freq = {};
+        for (const m of models) freq[m] = (freq[m] || 0) + 1;
+        topModel = Object.entries(freq).sort((a, b) => b[1] - a[1])[0][0];
+      }
+    } catch {}
+    if (!topModel) continue;
+    let inTok = r.inTok || 0, outTok = r.outTok || 0;
+    if (inTok === 0 && outTok === 0 && ((r.uChars || 0) > 0 || (r.aChars || 0) > 0)) {
+      inTok = Math.round((r.uChars || 0) / 4);
+      outTok = Math.round((r.aChars || 0) / 4);
+    }
+    const cost = calculateCost(topModel, inTok, outTok, r.cacheR || 0, r.cacheW || 0) || 0;
+    if (cost > 0) {
+      sessionCosts.push({
+        id: r.id, source: r.source, name: r.name, folder: r.folder,
+        model: normalizeModelName(topModel) || topModel,
+        cost, messages: r.msgs || 0,
+        lastUpdatedAt: r.last_updated_at || r.created_at,
+      });
+    }
+  }
+  sessionCosts.sort((a, b) => b.cost - a.cost);
+
+  // Summary stats
+  const totalSessions = sessionCosts.length;
+  const avgPerSession = totalSessions > 0 ? overall.totalCost / totalSessions : 0;
+  const totalDays = monthly.length > 0 ? (() => {
+    const first = new Date(monthly[0].month + '-01');
+    const last = new Date(monthly[monthly.length - 1].month + '-01');
+    return Math.max(1, Math.ceil((last - first) / 86400000) + 30);
+  })() : 1;
+  const avgPerDay = overall.totalCost / totalDays;
+
+  return {
+    totalCost: overall.totalCost,
+    byModel: overall.byModel,
+    unknownModels: overall.unknownModels,
+    byEditor,
+    byProject: byProject.slice(0, 20),
+    monthly,
+    topSessions: sessionCosts.slice(0, 50),
+    summary: {
+      totalSessions,
+      avgPerSession: Math.round(avgPerSession * 100) / 100,
+      avgPerDay: Math.round(avgPerDay * 100) / 100,
+      totalDays,
+    },
+  };
+}
+
 function getDb() { return db; }
 
 module.exports = {
@@ -871,5 +1300,7 @@ module.exports = {
   resetAndRescan,
   resetAndRescanAsync,
   getCachedDashboardStats,
+  getCostBreakdown,
+  getCostAnalytics,
   getDb,
 };

package/editors/cursor.js

@@ -91,11 +91,6 @@ function normalizeStoreMessage(json) {
     }
   }
   if (json.model) msg._model = json.model;
-  // Extract provider as model hint if no explicit model
-  if (!msg._model && json.providerOptions && typeof json.providerOptions === 'object') {
-    const providers = Object.keys(json.providerOptions).filter(k => k !== 'type');
-    if (providers.length > 0) msg._model = providers[0];
-  }
   return msg;
 }
 
@@ -159,6 +154,15 @@ function getComposerHeaders(stateDbPath) {
   } catch { return []; }
 }
 
+function getModelPreference(globalDb) {
+  try {
+    const row = globalDb.prepare("SELECT value FROM ItemTable WHERE key = 'cursor/lastSingleModelPreference'").get();
+    if (!row) return null;
+    const pref = JSON.parse(row.value);
+    return pref.composer || pref.agent || null;
+  } catch { return null; }
+}
+
 function getComposerBubbles(globalDb, composerId) {
   const prefix = `bubbleId:${composerId}:`;
   const rows = globalDb.prepare(
@@ -260,9 +264,11 @@ function getChats() {
           composerId: chatId,
           name: meta.name || null,
           createdAt: meta.createdAt || null,
+          mode: meta.mode || null,
           folder: null,
           _dbPath: dbPath,
           _rootBlobId: meta.latestRootBlobId,
+          _lastUsedModel: meta.lastUsedModel || null,
           _type: 'agent-store',
         });
       }
@@ -273,6 +279,8 @@ function getChats() {
   let globalDb = null;
   try { globalDb = new Database(GLOBAL_STORAGE_DB, { readonly: true }); } catch { /* no global db */ }
 
+  const modelPref = globalDb ? getModelPreference(globalDb) : null;
+
   for (const { hash, folder, stateDb } of getWorkspaceMap()) {
     const headers = getComposerHeaders(stateDb);
     for (const h of headers) {
@@ -295,6 +303,7 @@ function getChats() {
         folder,
         bubbleCount,
         _type: 'workspace',
+        _modelPref: modelPref,
       });
     }
   }
@@ -308,6 +317,12 @@ function getMessages(chat) {
     const db = new Database(chat._dbPath, { readonly: true });
     const msgs = collectStoreMessages(db, chat._rootBlobId);
     db.close();
+    // Use lastUsedModel as fallback for assistant messages without model info
+    if (chat._lastUsedModel) {
+      for (const m of msgs) {
+        if (m.role === 'assistant' && !m._model) m._model = chat._lastUsedModel;
+      }
+    }
     return msgs;
   }
 
@@ -315,7 +330,14 @@ function getMessages(chat) {
   try { globalDb = new Database(GLOBAL_STORAGE_DB, { readonly: true }); } catch { return []; }
   const bubbles = getComposerBubbles(globalDb, chat.composerId);
   globalDb.close();
-  return bubblesToMessages(bubbles);
+  const msgs = bubblesToMessages(bubbles);
+  // Use model preference as fallback for messages without model info
+  if (chat._modelPref) {
+    for (const m of msgs) {
+      if (m.role === 'assistant' && !m._model) m._model = chat._modelPref;
+    }
+  }
+  return msgs;
 }
 
 module.exports = { name, getChats, getMessages };