metrascope 0.1.0

package/src/adapters/codex.js

@@ -0,0 +1,173 @@
+// Codex CLI adapter — reads ~/.codex session JSONL with token_count events.
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { expandHome, parseJSONLFile, readJSONLMap, walkJSONL, textFromContent, projectFromCwd } = require('./shared');
+const { buildResult, emptyResult, buildPromptBreakdown } = require('./aggregate');
+
+const id = 'codex';
+const label = 'Codex';
+const mark = 'CX';
+const accent = '#d4a44a';
+const capabilities = { cost: false, reasoning: true, rateLimit: true, cache: true, tools: true, contextWindow: true };
+
+function home(options = {}) {
+  return expandHome(options.home || options.codexHome || process.env.CODEX_HOME) || path.join(os.homedir(), '.codex');
+}
+
+function detect(options = {}) {
+  const h = home(options);
+  return fs.existsSync(path.join(h, 'sessions')) || fs.existsSync(path.join(h, 'archived_sessions'));
+}
+
+function isHumanPrompt(text) {
+  if (!text) return false;
+  const value = String(text).trim();
+  if (!value) return false;
+  if (value.startsWith('<environment_context>')) return false;
+  if (value.startsWith('The following is the Codex agent history')) return false;
+  if (value.startsWith('Continue the same review conversation')) return false;
+  if (value.startsWith('You are reviewing an already-completed Codex turn')) return false;
+  return true;
+}
+
+function extractSessionId(filePath, metaId) {
+  if (metaId) return metaId;
+  const base = path.basename(filePath, '.jsonl');
+  const match = base.match(/([0-9a-f]{8}-[0-9a-f-]{27,})$/i);
+  return match ? match[1] : base;
+}
+
+function tokenUsageFromPayload(payload) {
+  if (!payload || payload.type !== 'token_count') return null;
+  const info = payload.info || {};
+  const last = info.last_token_usage || {};
+  const total = info.total_token_usage || {};
+  return {
+    inputTokens: last.input_tokens || 0,
+    cachedInputTokens: last.cached_input_tokens || 0,
+    outputTokens: last.output_tokens || 0,
+    reasoningOutputTokens: last.reasoning_output_tokens || 0,
+    totalTokens: last.total_tokens || 0,
+    cumulativeTokens: total.total_tokens || 0,
+    cumulativeInputTokens: total.input_tokens || 0,
+    cumulativeCachedInputTokens: total.cached_input_tokens || 0,
+    cumulativeOutputTokens: total.output_tokens || 0,
+    cumulativeReasoningOutputTokens: total.reasoning_output_tokens || 0,
+    contextWindow: info.model_context_window || null,
+    rateLimits: payload.rate_limits || null,
+  };
+}
+
+function latestRateLimit(rateLimits, previous) {
+  if (!rateLimits) return previous || null;
+  return {
+    planType: rateLimits.plan_type || previous?.planType || null,
+    limitId: rateLimits.limit_id || previous?.limitId || null,
+    primaryUsedPercent: rateLimits.primary?.used_percent ?? previous?.primaryUsedPercent ?? null,
+    primaryWindowMinutes: rateLimits.primary?.window_minutes ?? previous?.primaryWindowMinutes ?? null,
+    primaryResetsAt: rateLimits.primary?.resets_at ?? previous?.primaryResetsAt ?? null,
+    secondaryUsedPercent: rateLimits.secondary?.used_percent ?? previous?.secondaryUsedPercent ?? null,
+    secondaryWindowMinutes: rateLimits.secondary?.window_minutes ?? previous?.secondaryWindowMinutes ?? null,
+    secondaryResetsAt: rateLimits.secondary?.resets_at ?? previous?.secondaryResetsAt ?? null,
+    reachedType: rateLimits.rate_limit_reached_type || previous?.reachedType || null,
+  };
+}
+
+function sumTurns(turns, key) {
+  return turns.reduce((t, x) => t + (x[key] || 0), 0);
+}
+
+function extractSession(entries, filePath, titleMap, promptMap) {
+  let meta = {};
+  let model = 'unknown';
+  let currentUserPrompt = null;
+  let currentTurnId = null;
+  let latestRate = null;
+  const turns = [];
+  const toolCounts = {};
+  const toolEvents = [];
+  let agentMessages = 0;
+
+  for (const entry of entries) {
+    const payload = entry.payload || {};
+    if (entry.type === 'session_meta') { meta = payload; model = payload.model || model; continue; }
+    if (entry.type === 'turn_context') { currentTurnId = payload.turn_id || currentTurnId; model = payload.model || model; continue; }
+    if (payload.type === 'user_message') { if (isHumanPrompt(payload.message)) currentUserPrompt = payload.message; currentTurnId = payload.turn_id || currentTurnId; continue; }
+    if (entry.type === 'response_item' && payload.type === 'message' && payload.role === 'user') {
+      const text = textFromContent(payload.content);
+      if (isHumanPrompt(text)) currentUserPrompt = text;
+      continue;
+    }
+    if (entry.type === 'response_item' && payload.type === 'function_call') {
+      const name = payload.name || 'tool';
+      toolCounts[name] = (toolCounts[name] || 0) + 1;
+      toolEvents.push({ name, timestamp: entry.timestamp, prompt: currentUserPrompt || null, turnId: currentTurnId || null });
+      continue;
+    }
+    if (payload.type === 'agent_message') { agentMessages += 1; continue; }
+    const usage = tokenUsageFromPayload(payload);
+    if (usage) {
+      latestRate = latestRateLimit(usage.rateLimits, latestRate);
+      turns.push({ turnId: payload.turn_id || currentTurnId || `turn-${turns.length + 1}`, timestamp: entry.timestamp, prompt: currentUserPrompt || null, model, ...usage });
+    }
+  }
+
+  const sessionId = extractSessionId(filePath, meta.id);
+  if (turns.length === 0 && agentMessages === 0 && Object.keys(toolCounts).length === 0) return null;
+
+  const lastTurn = turns[turns.length - 1] || {};
+  const peakInputTokens = turns.reduce((max, t) => Math.max(max, t.inputTokens || 0), 0);
+  const peakTurnTokens = turns.reduce((max, t) => Math.max(max, t.totalTokens || 0), 0);
+  const firstTimestamp = meta.timestamp || entries.find((e) => e.timestamp)?.timestamp || null;
+  const updatedTimestamp = entries.slice().reverse().find((e) => e.timestamp)?.timestamp || firstTimestamp;
+  const date = firstTimestamp ? firstTimestamp.split('T')[0] : 'unknown';
+  const titleCandidate = titleMap[sessionId];
+  const historyPrompt = promptMap[sessionId];
+  const title = (isHumanPrompt(titleCandidate) && titleCandidate)
+    || (isHumanPrompt(historyPrompt) && historyPrompt)
+    || (isHumanPrompt(currentUserPrompt) && currentUserPrompt)
+    || '(untitled Codex session)';
+  const project = projectFromCwd(meta.cwd || entries.find((e) => e.payload?.cwd)?.payload.cwd);
+  const promptBreakdown = buildPromptBreakdown(turns, toolEvents, title);
+
+  return {
+    sessionId, filePath,
+    archived: filePath.includes(`${path.sep}archived_sessions${path.sep}`),
+    title: String(title).slice(0, 240), project, cwd: meta.cwd || null, date,
+    timestamp: firstTimestamp, updatedTimestamp, model,
+    turnCount: turns.length, agentMessages,
+    toolCount: Object.values(toolCounts).reduce((s, n) => s + n, 0), toolCounts,
+    promptCount: promptBreakdown.length, promptBreakdown, turns,
+    inputTokens: lastTurn.cumulativeInputTokens || sumTurns(turns, 'inputTokens'),
+    cachedInputTokens: lastTurn.cumulativeCachedInputTokens || sumTurns(turns, 'cachedInputTokens'),
+    outputTokens: lastTurn.cumulativeOutputTokens || sumTurns(turns, 'outputTokens'),
+    reasoningOutputTokens: lastTurn.cumulativeReasoningOutputTokens || sumTurns(turns, 'reasoningOutputTokens'),
+    totalTokens: lastTurn.cumulativeTokens || sumTurns(turns, 'totalTokens'),
+    contextWindow: lastTurn.contextWindow || null, peakInputTokens, peakTurnTokens, rateLimit: latestRate,
+  };
+}
+
+async function parse(options = {}) {
+  const h = home(options);
+  const source = { id, label, mark, accent, home: h };
+  if (!fs.existsSync(h)) return emptyResult(source, capabilities, [{ type: 'missing-dir', message: `Codex home not found at ${h}` }]);
+
+  const titleMap = await readJSONLMap(path.join(h, 'session_index.jsonl'), (e) => e.id, (e) => e.thread_name || e.id);
+  const promptMap = await readJSONLMap(path.join(h, 'history.jsonl'), (e) => e.session_id, (e) => e.text);
+  const files = [...walkJSONL(path.join(h, 'sessions')), ...walkJSONL(path.join(h, 'archived_sessions'))];
+  if (files.length === 0) return emptyResult(source, capabilities, [{ type: 'no-sessions', message: 'No Codex session JSONL files found.' }]);
+
+  const warnings = [];
+  const sessions = [];
+  for (const filePath of files) {
+    let entries;
+    try { entries = await parseJSONLFile(filePath); }
+    catch (err) { warnings.push({ type: 'read-failed', message: `Could not read ${filePath}: ${err.message}` }); continue; }
+    const session = extractSession(entries, filePath, titleMap, promptMap);
+    if (session) sessions.push(session);
+  }
+  return buildResult(sessions, source, capabilities, warnings);
+}
+
+module.exports = { id, label, mark, accent, capabilities, home, detect, parse };

package/src/adapters/gemini.js

@@ -0,0 +1,30 @@
+// Gemini CLI adapter — detected for completeness, but Gemini's local chat logs
+// are an event-sourced format that does not record per-turn token usage, so
+// there is nothing to chart. Reported as detected-but-unsupported.
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { expandHome } = require('./shared');
+const { emptyResult } = require('./aggregate');
+
+const id = 'gemini';
+const label = 'Gemini CLI';
+const mark = 'GE';
+const accent = '#5a8fd6';
+const capabilities = { cost: false, reasoning: false, rateLimit: false, cache: false, tools: false, contextWindow: false };
+
+function home(options = {}) {
+  return expandHome(options.home || process.env.GEMINI_HOME) || path.join(os.homedir(), '.gemini');
+}
+function detect(options = {}) {
+  return fs.existsSync(path.join(home(options), 'tmp')) || fs.existsSync(path.join(home(options), 'history'));
+}
+async function parse(options = {}) {
+  const h = home(options);
+  return emptyResult({ id, label, mark, accent, home: h }, capabilities, [{
+    type: 'no-token-data',
+    message: 'Gemini CLI does not record per-turn token usage in its local logs, so there is nothing to chart yet.',
+  }]);
+}
+
+module.exports = { id, label, mark, accent, capabilities, home, detect, parse };

package/src/adapters/index.js

@@ -0,0 +1,29 @@
+// Agent adapter registry. Add new coding agents by dropping an adapter module
+// here that exports { id, label, mark, accent, capabilities, home, detect, parse }.
+const codex = require('./codex');
+const claude = require('./claude');
+const qwen = require('./qwen');
+const opencode = require('./opencode');
+const gemini = require('./gemini');
+
+const ADAPTERS = [codex, claude, qwen, opencode, gemini];
+
+function list() {
+  return ADAPTERS.map((a) => ({
+    id: a.id, label: a.label, mark: a.mark, accent: a.accent,
+    capabilities: a.capabilities, home: a.home(), available: a.detect(),
+  }));
+}
+
+function get(sourceId) {
+  return ADAPTERS.find((a) => a.id === sourceId) || null;
+}
+
+// First available adapter, preferring Codex, then anything detected.
+function defaultSourceId() {
+  const available = list().filter((s) => s.available);
+  if (available.find((s) => s.id === 'codex')) return 'codex';
+  return (available[0] || list()[0]).id;
+}
+
+module.exports = { list, get, defaultSourceId, ADAPTERS };

package/src/adapters/opencode.js

@@ -0,0 +1,155 @@
+// OpenCode adapter — reads the SQLite store at ~/.local/share/opencode/opencode.db
+// (session/message/part tables; assistant messages carry tokens + cost).
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { expandHome, projectFromCwd } = require('./shared');
+const { buildResult, emptyResult, buildPromptBreakdown } = require('./aggregate');
+
+const id = 'opencode';
+const label = 'OpenCode';
+const mark = 'OC';
+const accent = '#3fb6a8';
+const capabilities = { cost: true, reasoning: true, rateLimit: false, cache: true, tools: true, contextWindow: false };
+
+function dataDir(options = {}) {
+  const explicit = expandHome(options.home || process.env.OPENCODE_DATA);
+  if (explicit) return explicit;
+  const xdg = process.env.XDG_DATA_HOME;
+  return xdg ? path.join(xdg, 'opencode') : path.join(os.homedir(), '.local', 'share', 'opencode');
+}
+function dbPath(options = {}) {
+  return path.join(dataDir(options), 'opencode.db');
+}
+function home(options = {}) {
+  return dbPath(options);
+}
+function detect(options = {}) {
+  return fs.existsSync(dbPath(options));
+}
+
+function loadSqlite() {
+  try { return require('node:sqlite').DatabaseSync; } catch { return null; }
+}
+
+function safeParse(json) {
+  try { return JSON.parse(json); } catch { return {}; }
+}
+
+function toolNameFromPart(d) {
+  if (!d) return null;
+  const t = String(d.type || '');
+  if (t === 'tool' || t.includes('tool')) {
+    return d.tool || d.name || d.toolName || (d.toolInvocation && d.toolInvocation.toolName) || 'tool';
+  }
+  return null;
+}
+
+async function parse(options = {}) {
+  const file = dbPath(options);
+  const source = { id, label, mark, accent, home: file };
+  if (!fs.existsSync(file)) return emptyResult(source, capabilities, [{ type: 'missing-dir', message: `OpenCode database not found at ${file}` }]);
+  const DatabaseSync = loadSqlite();
+  if (!DatabaseSync) return emptyResult(source, capabilities, [{ type: 'no-sqlite', message: 'node:sqlite is unavailable (needs Node 22.5+). Cannot read the OpenCode database.' }]);
+
+  let db;
+  try { db = new DatabaseSync(file, { readOnly: true }); }
+  catch (err) { return emptyResult(source, capabilities, [{ type: 'read-failed', message: `Could not open OpenCode database: ${err.message}` }]); }
+
+  const warnings = [];
+  let sessions = [];
+  try {
+    const sessionRows = db.prepare('SELECT * FROM session ORDER BY time_updated DESC').all();
+    const messageRows = db.prepare('SELECT id, session_id, time_created, data FROM message ORDER BY time_created ASC').all();
+    const partRows = db.prepare('SELECT message_id, session_id, data FROM part').all();
+
+    const msgBySession = {};
+    for (const m of messageRows) (msgBySession[m.session_id] = msgBySession[m.session_id] || []).push(m);
+    const partsByMessage = {};
+    for (const p of partRows) (partsByMessage[p.message_id] = partsByMessage[p.message_id] || []).push(safeParse(p.data));
+
+    for (const s of sessionRows) {
+      const messages = msgBySession[s.id] || [];
+      const turns = [];
+      const toolCounts = {};
+      const toolEvents = [];
+      let pendingPrompt = null;
+
+      for (const m of messages) {
+        const d = safeParse(m.data);
+        const parts = partsByMessage[m.id] || [];
+        if (d.role === 'user') {
+          const text = parts.filter((p) => p.type === 'text').map((p) => p.text).filter(Boolean).join('\n').trim();
+          if (text) pendingPrompt = text;
+          continue;
+        }
+        if (d.role === 'assistant') {
+          for (const p of parts) {
+            const name = toolNameFromPart(p);
+            if (name) {
+              toolCounts[name] = (toolCounts[name] || 0) + 1;
+              toolEvents.push({ name, prompt: pendingPrompt, timestamp: m.time_created });
+            }
+          }
+          const tk = d.tokens || {};
+          const cache = tk.cache || {};
+          const input = (tk.input || 0) + (cache.read || 0) + (cache.write || 0);
+          const reasoning = tk.reasoning || 0;
+          const output = (tk.output || 0) + reasoning;
+          turns.push({
+            turnId: m.id,
+            timestamp: new Date(m.time_created).toISOString(),
+            prompt: pendingPrompt,
+            model: d.modelID || d.model?.modelID || 'unknown',
+            inputTokens: input,
+            cachedInputTokens: cache.read || 0,
+            outputTokens: output,
+            reasoningOutputTokens: reasoning,
+            totalTokens: input + output,
+            contextWindow: null,
+            cost: d.cost || 0,
+          });
+        }
+      }
+
+      if (!turns.length && Object.keys(toolCounts).length === 0) continue;
+
+      const firstTs = new Date(s.time_created).toISOString();
+      const lastTs = new Date(s.time_updated || s.time_created).toISOString();
+      const date = firstTs.split('T')[0];
+      const sessionModel = safeParse(s.model).id || safeParse(s.model).modelID;
+      const modelCounts = {};
+      for (const t of turns) if (t.model && t.model !== 'unknown') modelCounts[t.model] = (modelCounts[t.model] || 0) + 1;
+      const primaryModel = Object.entries(modelCounts).sort((a, b) => b[1] - a[1])[0]?.[0] || sessionModel || 'unknown';
+      const title = turns.find((t) => t.prompt)?.prompt || (s.title && !s.title.startsWith('New session') ? s.title : null) || s.title || '(untitled OpenCode session)';
+      const promptBreakdown = buildPromptBreakdown(turns, toolEvents, title);
+
+      sessions.push({
+        sessionId: s.id, filePath: file, archived: !!s.time_archived,
+        title: String(title).slice(0, 240),
+        project: projectFromCwd(s.directory || s.path), cwd: s.directory || null, date,
+        timestamp: firstTs, updatedTimestamp: lastTs, model: primaryModel,
+        turnCount: turns.length, agentMessages: turns.length,
+        toolCount: Object.values(toolCounts).reduce((a, n) => a + n, 0), toolCounts,
+        promptCount: promptBreakdown.length, promptBreakdown, turns,
+        inputTokens: turns.reduce((a, t) => a + t.inputTokens, 0),
+        cachedInputTokens: turns.reduce((a, t) => a + t.cachedInputTokens, 0),
+        outputTokens: turns.reduce((a, t) => a + t.outputTokens, 0),
+        reasoningOutputTokens: turns.reduce((a, t) => a + t.reasoningOutputTokens, 0),
+        totalTokens: turns.reduce((a, t) => a + t.totalTokens, 0),
+        cost: turns.reduce((a, t) => a + (t.cost || 0), 0),
+        contextWindow: null, peakInputTokens: turns.reduce((mx, t) => Math.max(mx, t.inputTokens || 0), 0),
+        peakTurnTokens: turns.reduce((mx, t) => Math.max(mx, t.totalTokens || 0), 0), rateLimit: null,
+      });
+    }
+  } catch (err) {
+    warnings.push({ type: 'query-failed', message: `OpenCode database query failed: ${err.message}` });
+  } finally {
+    try { db.close(); } catch { /* */ }
+  }
+
+  if (!sessions.length) return emptyResult(source, capabilities, warnings.length ? warnings : [{ type: 'no-sessions', message: 'No OpenCode sessions found yet. Use OpenCode and refresh.' }]);
+  return buildResult(sessions, source, capabilities, warnings);
+}
+
+module.exports = { id, label, mark, accent, capabilities, home, detect, parse };

package/src/adapters/qwen.js

@@ -0,0 +1,138 @@
+// Qwen Code adapter — reads ~/.qwen/projects/**/chats/*.jsonl
+// (Claude-style transcript lines carrying Gemini-style usageMetadata).
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { expandHome, parseJSONLFile, walkJSONL, textFromContent, projectFromCwd } = require('./shared');
+const { buildResult, emptyResult, buildPromptBreakdown } = require('./aggregate');
+
+const id = 'qwen';
+const label = 'Qwen Code';
+const mark = 'QC';
+const accent = '#7c6bd6';
+const capabilities = { cost: false, reasoning: true, rateLimit: false, cache: true, tools: true, contextWindow: true };
+
+function home(options = {}) {
+  return expandHome(options.home || process.env.QWEN_HOME) || path.join(os.homedir(), '.qwen');
+}
+function detect(options = {}) {
+  return fs.existsSync(path.join(home(options), 'projects'));
+}
+
+function partsText(parts) {
+  if (typeof parts === 'string') return parts;
+  if (!Array.isArray(parts)) return '';
+  return parts.map((p) => (typeof p === 'string' ? p : p.text || '')).filter(Boolean).join('\n');
+}
+function isHumanPrompt(text) {
+  if (!text) return false;
+  const v = String(text).trim();
+  if (!v) return false;
+  if (v.startsWith('<environment') || v.startsWith('This is the Qwen Code') || v.startsWith('You are')) return false;
+  return true;
+}
+
+function extractSession(entries, filePath) {
+  let model = 'unknown';
+  let cwd = null;
+  let pendingPrompt = null;
+  let contextWindow = null;
+  const turns = [];
+  const toolCounts = {};
+  const toolEvents = [];
+
+  for (const entry of entries) {
+    if (entry.cwd && !cwd) cwd = entry.cwd;
+    if (entry.contextWindowSize) contextWindow = entry.contextWindowSize;
+    const msg = entry.message || {};
+    if (entry.type === 'user' || msg.role === 'user') {
+      const text = partsText(msg.parts != null ? msg.parts : msg.content) || textFromContent(msg.content) || entry.text;
+      if (isHumanPrompt(text)) pendingPrompt = text;
+    }
+    // Tool calls appear as functionCall parts on assistant/model messages.
+    const parts = Array.isArray(msg.parts) ? msg.parts : [];
+    for (const p of parts) {
+      const fc = p.functionCall || p.toolCall;
+      if (fc && fc.name) {
+        toolCounts[fc.name] = (toolCounts[fc.name] || 0) + 1;
+        toolEvents.push({ name: fc.name, prompt: pendingPrompt, timestamp: entry.timestamp });
+      }
+    }
+    const um = entry.usageMetadata || msg.usageMetadata;
+    if (um && (um.totalTokenCount || um.promptTokenCount || um.candidatesTokenCount)) {
+      const m = entry.model || msg.model || model;
+      model = m || model;
+      const input = um.promptTokenCount || 0;
+      const cached = um.cachedContentTokenCount || 0;
+      const reasoning = um.thoughtsTokenCount || 0;
+      const output = (um.candidatesTokenCount || 0) + reasoning; // visible + thoughts
+      const total = um.totalTokenCount || input + output;
+      turns.push({
+        turnId: entry.uuid || `turn-${turns.length + 1}`,
+        timestamp: entry.timestamp,
+        prompt: pendingPrompt,
+        model: m,
+        inputTokens: input,
+        cachedInputTokens: cached,
+        outputTokens: output,
+        reasoningOutputTokens: reasoning,
+        totalTokens: total,
+        contextWindow: entry.contextWindowSize || contextWindow || null,
+      });
+    }
+  }
+
+  if (!turns.length && Object.keys(toolCounts).length === 0) return null;
+  const sessionId = entries.find((e) => e.sessionId)?.sessionId || path.basename(filePath, '.jsonl');
+  const firstTs = entries.find((e) => e.timestamp)?.timestamp || null;
+  const lastTs = entries.slice().reverse().find((e) => e.timestamp)?.timestamp || firstTs;
+  const date = firstTs ? firstTs.split('T')[0] : 'unknown';
+  const project = projectFromCwd(cwd);
+  const modelCounts = {};
+  for (const t of turns) if (t.model) modelCounts[t.model] = (modelCounts[t.model] || 0) + 1;
+  const primaryModel = Object.entries(modelCounts).sort((a, b) => b[1] - a[1])[0]?.[0] || model;
+  const title = turns.find((t) => isHumanPrompt(t.prompt))?.prompt
+    || entries.find((e) => isHumanPrompt(partsText(e.message?.parts) || e.text))?.text
+    || '(untitled Qwen session)';
+  const promptBreakdown = buildPromptBreakdown(turns, toolEvents, title);
+  const peakInputTokens = turns.reduce((mx, t) => Math.max(mx, t.inputTokens || 0), 0);
+
+  return {
+    sessionId, filePath, archived: false,
+    title: String(title).slice(0, 240), project, cwd, date,
+    timestamp: firstTs, updatedTimestamp: lastTs, model: primaryModel,
+    turnCount: turns.length, agentMessages: turns.length,
+    toolCount: Object.values(toolCounts).reduce((s, n) => s + n, 0), toolCounts,
+    promptCount: promptBreakdown.length, promptBreakdown, turns,
+    inputTokens: turns.reduce((s, t) => s + t.inputTokens, 0),
+    cachedInputTokens: turns.reduce((s, t) => s + t.cachedInputTokens, 0),
+    outputTokens: turns.reduce((s, t) => s + t.outputTokens, 0),
+    reasoningOutputTokens: turns.reduce((s, t) => s + t.reasoningOutputTokens, 0),
+    totalTokens: turns.reduce((s, t) => s + t.totalTokens, 0),
+    contextWindow, peakInputTokens, peakTurnTokens: turns.reduce((mx, t) => Math.max(mx, t.totalTokens || 0), 0),
+    rateLimit: null,
+  };
+}
+
+async function parse(options = {}) {
+  const h = home(options);
+  const source = { id, label, mark, accent, home: h };
+  const projectsDir = path.join(h, 'projects');
+  if (!fs.existsSync(projectsDir)) return emptyResult(source, capabilities, [{ type: 'missing-dir', message: `Qwen Code data not found at ${projectsDir}` }]);
+  const files = walkJSONL(projectsDir);
+  if (!files.length) return emptyResult(source, capabilities, [{ type: 'no-sessions', message: 'No Qwen Code chat JSONL files found.' }]);
+
+  const warnings = [];
+  const sessions = [];
+  for (const filePath of files) {
+    let entries;
+    try { entries = await parseJSONLFile(filePath); } catch { continue; }
+    if (!entries.length) continue;
+    const session = extractSession(entries, filePath);
+    if (session) sessions.push(session);
+  }
+  if (!sessions.length) return emptyResult(source, capabilities, [{ type: 'no-usage', message: 'No Qwen Code sessions with token usage found.' }]);
+  return buildResult(sessions, source, capabilities, warnings);
+}
+
+module.exports = { id, label, mark, accent, capabilities, home, detect, parse };

package/src/adapters/shared.js

@@ -0,0 +1,87 @@
+// Generic helpers shared by every agent adapter.
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const readline = require('readline');
+
+function expandHome(inputPath) {
+  if (!inputPath) return null;
+  if (inputPath === '~') return os.homedir();
+  if (inputPath.startsWith('~/')) return path.join(os.homedir(), inputPath.slice(2));
+  return inputPath;
+}
+
+async function parseJSONLFile(filePath) {
+  const entries = [];
+  const stream = fs.createReadStream(filePath, { encoding: 'utf8' });
+  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    try {
+      entries.push(JSON.parse(line));
+    } catch {
+      // A single bad line should not hide the rest of the dashboard.
+    }
+  }
+  return entries;
+}
+
+async function readJSONLMap(filePath, getKey, getValue) {
+  const map = {};
+  if (!fs.existsSync(filePath)) return map;
+  const entries = await parseJSONLFile(filePath);
+  for (const entry of entries) {
+    const key = getKey(entry);
+    if (!key || map[key]) continue;
+    map[key] = getValue(entry);
+  }
+  return map;
+}
+
+function walkJSONL(dir, files = []) {
+  if (!fs.existsSync(dir)) return files;
+  for (const name of fs.readdirSync(dir)) {
+    const filePath = path.join(dir, name);
+    let stat;
+    try {
+      stat = fs.statSync(filePath);
+    } catch {
+      continue;
+    }
+    if (stat.isDirectory()) walkJSONL(filePath, files);
+    else if (name.endsWith('.jsonl')) files.push(filePath);
+  }
+  return files;
+}
+
+function textFromContent(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  return content.map((block) => {
+    if (typeof block === 'string') return block;
+    return block.text || block.message || '';
+  }).filter(Boolean).join('\n');
+}
+
+function projectFromCwd(cwd) {
+  if (!cwd) return 'unknown';
+  const home = os.homedir();
+  let label = cwd.startsWith(home) ? '~' + cwd.slice(home.length) : cwd;
+  const parts = label.split(path.sep).filter(Boolean);
+  if (parts.length <= 2) return label || 'unknown';
+  return parts.slice(-2).join(path.sep);
+}
+
+function sum(items, key) {
+  return items.reduce((total, item) => total + (item[key] || 0), 0);
+}
+
+function fmt(n) {
+  n = Number(n || 0);
+  if (n >= 1_000_000) return (n / 1_000_000).toFixed(1) + 'M';
+  if (n >= 10_000) return Math.round(n / 1000) + 'K';
+  if (n >= 1000) return (n / 1000).toFixed(1) + 'K';
+  return n.toLocaleString();
+}
+
+module.exports = { expandHome, parseJSONLFile, readJSONLMap, walkJSONL, textFromContent, projectFromCwd, sum, fmt };