burner-cc 0.1.2 → 0.3.0

package/src/model/prior.meta.json

@@ -0,0 +1,320 @@
+{
+  "trainedAt": "2026-10-25T10:33:58.921Z",
+  "recommended": false,
+  "datasets": [
+    {
+      "id": "dolly",
+      "name": "databricks/databricks-dolly-15k",
+      "license": "CC-BY-SA-3.0",
+      "url": "https://huggingface.co/datasets/databricks/databricks-dolly-15k",
+      "examplesUsed": 2809
+    },
+    {
+      "id": "no_robots",
+      "name": "HuggingFaceH4/no_robots",
+      "license": "CC-BY-NC-4.0",
+      "url": "https://huggingface.co/datasets/HuggingFaceH4/no_robots",
+      "examplesUsed": 2253
+    },
+    {
+      "id": "code_instructions",
+      "name": "iamtarun/python_code_instructions_18k_alpaca",
+      "license": "See dataset card (instruction-tuning; widely redistributed)",
+      "url": "https://huggingface.co/datasets/iamtarun/python_code_instructions_18k_alpaca",
+      "examplesUsed": 971
+    },
+    {
+      "id": "swe_bench",
+      "name": "princeton-nlp/SWE-bench",
+      "license": "MIT (per SWE-bench repository)",
+      "url": "https://huggingface.co/datasets/princeton-nlp/SWE-bench",
+      "examplesUsed": 1000
+    },
+    {
+      "id": "sql_context",
+      "name": "b-mc2/sql-create-context",
+      "license": "See dataset card (Spider-derived text-to-SQL context)",
+      "url": "https://huggingface.co/datasets/b-mc2/sql-create-context",
+      "examplesUsed": 762
+    },
+    {
+      "id": "github_codereview",
+      "name": "ronantakizawa/github-codereview",
+      "license": "Permissive (source repos MIT/Apache/BSD per dataset card)",
+      "url": "https://huggingface.co/datasets/ronantakizawa/github-codereview",
+      "examplesUsed": 1000
+    }
+  ],
+  "rejectedDatasets": [
+    {
+      "name": "lmsys/lmsys-chat-1m",
+      "reason": "Not accessible via public datasets-server (gated/private)."
+    },
+    {
+      "name": "irfanalee/github-code-review-full",
+      "reason": "No parquet config on datasets-server; raw JSONL paths not available without LFS pull."
+    },
+    {
+      "name": "allenai/WildChat",
+      "reason": "Ungated download works but has no intent/task labels suitable for honest mapping."
+    }
+  ],
+  "labelMappings": {
+    "dolly": {
+      "brainstorming": "planning",
+      "summarization": "writing",
+      "creative_writing": "writing",
+      "classification": "analysis",
+      "information_extraction": "research",
+      "open_qa": "learning",
+      "closed_qa": "learning",
+      "general_qa": "learning"
+    },
+    "no_robots": {
+      "Coding": "coding",
+      "Brainstorm": "planning",
+      "Summarize": "writing",
+      "Generation": "writing",
+      "Rewrite": "writing",
+      "Open QA": "learning",
+      "Closed QA": "learning",
+      "Extract": "research",
+      "Classify": "analysis",
+      "Chat": "other"
+    },
+    "code_instructions": {
+      "code_instruction": "coding"
+    },
+    "swe_bench": {
+      "bug_report": "debugging"
+    },
+    "sql_context": {
+      "text_to_sql": "analysis"
+    },
+    "github_codereview": {
+      "code_review": "review"
+    }
+  },
+  "training": {
+    "seed": 42,
+    "capPerClass": 1000,
+    "trainExamples": 7036,
+    "testExamples": 1759,
+    "minFeatureCount": 2,
+    "topNPerClass": 600
+  },
+  "examplesPerClass": {
+    "other": 795,
+    "coding": 1000,
+    "debugging": 1000,
+    "planning": 1000,
+    "writing": 1000,
+    "review": 1000,
+    "research": 1000,
+    "learning": 1000,
+    "analysis": 1000
+  },
+  "evaluation": {
+    "holdout": {
+      "accuracy": 0.6646,
+      "macroF1": 0.6315,
+      "perClass": {
+        "analysis": {
+          "precision": 0.9551,
+          "recall": 0.85,
+          "f1": 0.8995,
+          "support": 200
+        },
+        "coding": {
+          "precision": 0.8117,
+          "recall": 0.97,
+          "f1": 0.8838,
+          "support": 200
+        },
+        "debugging": {
+          "precision": 0.9879,
+          "recall": 0.815,
+          "f1": 0.8932,
+          "support": 200
+        },
+        "learning": {
+          "precision": 0.2984,
+          "recall": 0.37,
+          "f1": 0.3304,
+          "support": 200
+        },
+        "other": {
+          "precision": 0.5502,
+          "recall": 1,
+          "f1": 0.7098,
+          "support": 159
+        },
+        "planning": {
+          "precision": 0.4663,
+          "recall": 0.9,
+          "f1": 0.6143,
+          "support": 200
+        },
+        "research": {
+          "precision": 0.3333,
+          "recall": 0.01,
+          "f1": 0.0194,
+          "support": 200
+        },
+        "review": {
+          "precision": 0.9766,
+          "recall": 0.835,
+          "f1": 0.9003,
+          "support": 200
+        },
+        "writing": {
+          "precision": 0.7792,
+          "recall": 0.3,
+          "f1": 0.4332,
+          "support": 200
+        }
+      },
+      "majorityBaseline": 0.1137,
+      "majorityClass": "debugging",
+      "evaluated": 1759,
+      "confidentAccuracy": 0.708,
+      "confidentCoverage": 0.8977,
+      "confidentThreshold": 0.6
+    },
+    "crossDataset": {
+      "perDataset": {
+        "dolly": {
+          "skipped": false,
+          "testExamples": 2809,
+          "overlappingCategories": [
+            "writing",
+            "research",
+            "learning",
+            "planning",
+            "analysis"
+          ],
+          "accuracy": 0.3407,
+          "macroF1": 0.2643,
+          "majorityBaseline": 0.3158
+        },
+        "no_robots": {
+          "skipped": false,
+          "testExamples": 2253,
+          "overlappingCategories": [
+            "planning",
+            "writing",
+            "learning",
+            "research",
+            "coding",
+            "analysis"
+          ],
+          "accuracy": 0.2166,
+          "macroF1": 0.1463,
+          "majorityBaseline": 0.3529
+        },
+        "code_instructions": {
+          "skipped": true,
+          "reason": "fewer than 2 overlapping categories"
+        },
+        "swe_bench": {
+          "skipped": true,
+          "reason": "fewer than 2 overlapping categories"
+        },
+        "sql_context": {
+          "skipped": true,
+          "reason": "fewer than 2 overlapping categories"
+        },
+        "github_codereview": {
+          "skipped": true,
+          "reason": "fewer than 2 overlapping categories"
+        }
+      },
+      "avgMacroF1": 0.2053,
+      "avgAccuracy": 0.2787,
+      "datasetsScored": 2
+    }
+  },
+  "sanity": [
+    {
+      "prompt": "the login page crashes when I click submit",
+      "category": "coding",
+      "confidence": 0.738
+    },
+    {
+      "prompt": "write a PRD for onboarding new users",
+      "category": "coding",
+      "confidence": 0.924
+    },
+    {
+      "prompt": "summarize this Q3 sales spreadsheet into bullet points for leadership",
+      "category": "planning",
+      "confidence": 0.586
+    },
+    {
+      "prompt": "what does this function do? explain like I am new to the codebase",
+      "category": "planning",
+      "confidence": 0.902
+    },
+    {
+      "prompt": "review my PR for security issues before I merge",
+      "category": "review",
+      "confidence": 0.99
+    },
+    {
+      "prompt": "add a dark mode toggle to the settings page using our existing theme tokens",
+      "category": "review",
+      "confidence": 0.844
+    },
+    {
+      "prompt": "why is my Jest test failing with \"cannot read property of undefined\"",
+      "category": "review",
+      "confidence": 0.349
+    },
+    {
+      "prompt": "compare Postgres vs SQLite for our side project and recommend one",
+      "category": "learning",
+      "confidence": 0.472
+    },
+    {
+      "prompt": "draft an email to the customer apologizing for the outage",
+      "category": "coding",
+      "confidence": 0.605
+    },
+    {
+      "prompt": "plot month-over-month revenue from this CSV and call out anomalies",
+      "category": "coding",
+      "confidence": 0.704
+    },
+    {
+      "prompt": "break the epic into user stories with acceptance criteria",
+      "category": "other",
+      "confidence": 0.992
+    },
+    {
+      "prompt": "find where we authenticate API keys in this repo",
+      "category": "coding",
+      "confidence": 0.98
+    },
+    {
+      "prompt": "help me understand what a binary search tree is",
+      "category": "writing",
+      "confidence": 0.853
+    },
+    {
+      "prompt": "refactor this React component to use hooks instead of a class",
+      "category": "review",
+      "confidence": 0.9
+    },
+    {
+      "prompt": "check my migration script for data loss risks",
+      "category": "coding",
+      "confidence": 0.995
+    },
+    {
+      "prompt": "write release notes for version 2.4 from these commit messages",
+      "category": "debugging",
+      "confidence": 0.78
+    }
+  ],
+  "limitations": "Labels come from general instruction-tuning corpora (Q&A, summarization, coding exercises, bug reports, SQL questions, code-review diffs), not from Claude Code session logs. Categories such as planning and debugging are represented by narrower proxies (brainstorming prompts, SWE-bench issue text). Expect confusion between writing vs research, coding vs debugging, and analysis vs research on short prompts. The model should be treated as a weak default prior until a project trains on its own tagged sessions."
+}

package/src/parse.js

@@ -1,20 +1,108 @@
 import { readFileSync } from 'node:fs';
 
-// Reads one transcript file and returns a flat list of billed turns:
-// { model, timestamp, input, output, cacheWrite5m, cacheWrite1h, cacheRead }
-// plus a tool-activity tally: { mcp: {server: count}, skills: {name: count}, web: {WebFetch/WebSearch: count} }
-export function parseTranscript(file) {
+// Gateways and local servers are not always tidy: counts can arrive as
+// strings or null, and some use OpenAI-style names. Anything that is not a
+// finite non-negative number counts as 0 so one odd value can never turn a
+// total into NaN or a concatenated string.
+function tok(v) {
+  const n = Number(v);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : 0;
+}
+
+function normalizeUsage(u) {
+  const cc = u.cache_creation ?? {};
+  const hasSplit = cc.ephemeral_5m_input_tokens != null || cc.ephemeral_1h_input_tokens != null;
+  const createdTotal = tok(u.cache_creation_input_tokens);
+  return {
+    input: tok(u.input_tokens ?? u.prompt_tokens),
+    output: tok(u.output_tokens ?? u.completion_tokens),
+    cacheWrite5m: hasSplit ? tok(cc.ephemeral_5m_input_tokens) : createdTotal,
+    cacheWrite1h: hasSplit ? tok(cc.ephemeral_1h_input_tokens) : 0,
+    cacheRead: tok(u.cache_read_input_tokens ?? u.prompt_tokens_details?.cached_tokens),
+  };
+}
+
+const EMPTY_ACTIVITY = () => ({ mcp: {}, skills: {}, web: {} });
+
+function serverDisplayName(slug) {
+  return slug.replace(/_/g, ' ').trim();
+}
+
+function newBucket() {
+  return {
+    calls: 0,
+    outputTokens: 0,
+    contextTokens: 0,
+    contextMissing: 0,
+    outputByModel: {},
+    contextByModel: {},
+    via: {},
+  };
+}
+
+function userText(message) {
+  if (typeof message?.content === 'string') return message.content;
+  if (!Array.isArray(message?.content)) return '';
+  return message.content
+    .filter((b) => b.type === 'text' && typeof b.text === 'string')
+    .map((b) => b.text)
+    .join('\n');
+}
+
+// Prompts the human actually typed — not tool results, slash-command
+// scaffolding, or the "session continued" summaries Claude Code injects.
+function isHumanPrompt(entry, text) {
+  if (entry.isMeta || entry.isCompactSummary || entry.isSidechain) return false;
+  if (!text.trim()) return false;
+  if (/^<(command-|local-command|system-reminder|bash-|user-memory)/.test(text.trim())) return false;
+  if (text.startsWith('This session is being continued')) return false;
+  return true;
+}
+
+function toolStep(block) {
+  const name = block.name ?? 'unknown';
+  const input = block.input ?? {};
+  if (name === 'Bash' && typeof input.command === 'string') {
+    return `Bash(${input.command.trim().split(/\s+/).slice(0, 2).join(' ')})`;
+  }
+  const file = input.file_path ?? input.notebook_path ?? input.path;
+  if (typeof file === 'string') {
+    const ext = file.match(/\.([a-z0-9]+)$/i)?.[1];
+    return ext ? `${name}(.${ext.toLowerCase()})` : name;
+  }
+  if (name === 'Skill' && input.skill) return `Skill(${input.skill})`;
+  if (name === 'Task' || name === 'Agent') return `${name}(${input.subagent_type ?? 'agent'})`;
+  return name.startsWith('mcp__') ? `mcp:${name.split('__')[1]}` : name;
+}
+
+// Reads one transcript and returns:
+//  turns    — one entry per billed API request:
+//             { requestId, model, timestamp, input, output, cacheWrite5m, cacheWrite1h, cacheRead }
+//  activity — call counts { mcp: {server: n}, skills: {name: n}, web: {tool: n} }
+//  mcp/skills/web — per-request cost attribution buckets (see build-receipt.js)
+//  digest   — what the session was about: cwd, prompts, tool sequence
+//  reported — Claude Code's own "cost-state" totals when the transcript has one
+//
+// Claude Code writes one API response as several lines (one per content
+// block, streamed). They share a requestId/message.id; output_tokens grows
+// until the last one, so the final line is the billed usage.
+export function parseTranscript(path) {
+  const file = String(path);
   let text;
   try {
-    text = readFileSync(file, 'utf-8');
+    text = readFileSync(path, 'utf-8');
   } catch {
-    return { turns: [], activity: { mcp: {}, skills: {}, web: {} } };
+    return { turns: [], activity: EMPTY_ACTIVITY(), mcp: {}, skills: {}, web: {}, digest: emptyDigest(), reported: null };
   }
 
-  const turns = [];
-  const mcp = {};
-  const skills = {};
-  const web = {};
+  const requests = new Map();
+  const latest = new Map(); // base id -> newest request carrying it
+  const order = [];
+  let userCount = 0;
+  let splitN = 0;
+  const digest = emptyDigest();
+  let reported = null;
+  let anon = 0;
 
   for (const line of text.split('\n')) {
     if (!line.trim()) continue;
@@ -25,43 +113,119 @@ export function parseTranscript(file) {
       continue;
     }
 
+    if (!digest.cwd && typeof entry.cwd === 'string') digest.cwd = entry.cwd;
+    if (!digest.gitBranch && entry.gitBranch) digest.gitBranch = entry.gitBranch;
+    if (entry.type === 'ai-title' && entry.aiTitle) digest.aiTitle = entry.aiTitle;
+    if (entry.type === 'cost-state' && entry.modelUsage) reported = entry;
+
+    if (entry.type === 'user') userCount += 1;
+    if (entry.type === 'user' && entry.message?.role === 'user') {
+      const t = userText(entry.message);
+      if (isHumanPrompt(entry, t)) {
+        digest.prompts.push({ text: t.slice(0, 2000), timestamp: entry.timestamp ?? null });
+      }
+      continue;
+    }
+
     const msg = entry.message;
-    if (!msg || msg.type !== 'message' || msg.role !== 'assistant') continue;
+    if (!msg || msg.role !== 'assistant') continue;
+    if (msg.model === '<synthetic>') continue;
 
-    // Tool-call activity: tallied regardless of whether this line also
-    // carries usage, since a message can contain tool_use blocks either way.
+    // One API response is streamed as several lines sharing an id. Claude
+    // always supplies a unique requestId. A gateway may not: then message.id is
+    // all we have, and some servers reuse one constant id for every response,
+    // so a tool result in between means the id belongs to a new request.
+    const rid = entry.requestId || null;
+    const base = rid ?? (msg.id || null);
+    let req = base ? latest.get(base) : null;
+    if (req && !rid && req.lastUser !== userCount) req = null;
+    if (!req) {
+      const key = !base ? `${file}#anon${anon++}` : latest.has(base) ? `${file}#${base}#${++splitN}` : base;
+      req = { key, model: msg.model ?? 'unknown', timestamp: entry.timestamp ?? null, usage: null, tools: new Map(), skill: null, lastUser: userCount };
+      requests.set(key, req);
+      order.push(req);
+      if (base) latest.set(base, req);
+    }
+    req.lastUser = userCount;
+    if (entry.attributionSkill) req.skill = entry.attributionSkill;
+    if (msg.usage && typeof msg.usage === 'object' && (!req.usage || tok(msg.usage.output_tokens ?? msg.usage.completion_tokens) >= tok(req.usage.output_tokens ?? req.usage.completion_tokens))) {
+      req.usage = msg.usage;
+      req.model = msg.model ?? req.model;
+      if (entry.timestamp) req.timestamp = entry.timestamp;
+    }
     if (Array.isArray(msg.content)) {
       for (const block of msg.content) {
         if (block.type !== 'tool_use') continue;
-        if (block.name === 'Skill' && block.input?.skill) {
-          skills[block.input.skill] = (skills[block.input.skill] ?? 0) + 1;
-        } else if (block.name.startsWith('mcp__')) {
-          const server = block.name.split('__')[1] ?? 'unknown';
-          mcp[server] = (mcp[server] ?? 0) + 1;
-        } else if (block.name === 'WebFetch' || block.name === 'WebSearch') {
-          web[block.name] = (web[block.name] ?? 0) + 1;
-        }
+        const id = block.id ?? `${req.key}-${req.tools.size}`;
+        if (!req.tools.has(id)) req.tools.set(id, block);
       }
     }
+  }
 
-    if (!msg.usage) continue;
-    if (msg.model === '<synthetic>') continue; // internal zero-usage marker, not a billed turn
-
-    const u = msg.usage;
-    const isAllZero = !u.input_tokens && !u.output_tokens && !u.cache_creation_input_tokens && !u.cache_read_input_tokens;
-    if (isAllZero) continue;
-    const cacheCreation = u.cache_creation ?? {};
-    turns.push({
-      model: msg.model ?? 'unknown',
-      timestamp: entry.timestamp ?? null,
-      input: u.input_tokens ?? 0,
-      output: u.output_tokens ?? 0,
-      cacheWrite5m: cacheCreation.ephemeral_5m_input_tokens ?? u.cache_creation_input_tokens ?? 0,
-      cacheWrite1h: cacheCreation.ephemeral_1h_input_tokens ?? 0,
-      cacheRead: u.cache_read_input_tokens ?? 0,
-    });
+  const turns = [];
+  const billed = [];
+  for (const req of order) {
+    // Some local servers report no usage at all. Keep the request (so the
+    // model shows up and can be priced) but mark that its tokens are unknown.
+    const n = req.usage ? normalizeUsage(req.usage) : { input: 0, output: 0, cacheWrite5m: 0, cacheWrite1h: 0, cacheRead: 0 };
+    const unreported = !(n.input || n.output || n.cacheWrite5m || n.cacheWrite1h || n.cacheRead);
+    if (unreported && !req.model) continue;
+    const turn = { requestId: req.key, model: req.model, timestamp: req.timestamp, ...n, unreported };
+    turns.push(turn);
+    billed.push({ req, turn });
   }
-  return { turns, activity: { mcp, skills, web } };
+
+  const activity = EMPTY_ACTIVITY();
+  const mcp = {};
+  const skills = {};
+  const web = {};
+
+  billed.forEach(({ req, turn }, i) => {
+    const next = billed[i + 1]?.turn ?? null;
+    const charge = (bucket) => {
+      bucket.calls += 1;
+      bucket.outputTokens += turn.output;
+      bucket.outputByModel[turn.model] = (bucket.outputByModel[turn.model] ?? 0) + turn.output;
+      if (!next) {
+        bucket.contextMissing += 1;
+        return;
+      }
+      bucket.contextTokens += next.input + next.cacheWrite5m + next.cacheWrite1h;
+      const ctx = (bucket.contextByModel[next.model] ??= { input: 0, cacheWrite5m: 0, cacheWrite1h: 0 });
+      ctx.input += next.input;
+      ctx.cacheWrite5m += next.cacheWrite5m;
+      ctx.cacheWrite1h += next.cacheWrite1h;
+    };
+
+    const blocks = [...req.tools.values()];
+    let mcpCharged = false;
+    for (const block of blocks) {
+      const name = block.name ?? '';
+      digest.tools.push(toolStep(block));
+      if (name.startsWith('mcp__')) {
+        const [, slug = 'unknown', ...rest] = name.split('__');
+        const tool = rest.join('__') || 'unknown';
+        activity.mcp[slug] = (activity.mcp[slug] ?? 0) + 1;
+        const server = (mcp[slug] ??= { displayName: serverDisplayName(slug), tools: {} });
+        const bucket = (server.tools[tool] ??= newBucket());
+        charge(bucket);
+        if (req.skill) bucket.via[req.skill] = (bucket.via[req.skill] ?? 0) + 1;
+        mcpCharged = true;
+      } else if (name === 'Skill' && block.input?.skill) {
+        activity.skills[block.input.skill] = (activity.skills[block.input.skill] ?? 0) + 1;
+      } else if (name === 'WebFetch' || name === 'WebSearch') {
+        activity.web[name] = (activity.web[name] ?? 0) + 1;
+        web[name] = (web[name] ?? 0) + 1;
+      }
+    }
+    if (req.skill && !mcpCharged) charge((skills[req.skill] ??= newBucket()));
+  });
+
+  return { turns, activity, mcp, skills, web, digest, reported };
+}
+
+function emptyDigest() {
+  return { cwd: null, gitBranch: null, aiTitle: null, prompts: [], tools: [] };
 }
 
 export function timeRange(turns) {
@@ -70,11 +234,39 @@ export function timeRange(turns) {
 }
 
 export function mergeActivity(activities) {
-  const merged = { mcp: {}, skills: {}, web: {} };
+  const merged = EMPTY_ACTIVITY();
   for (const a of activities) {
-    for (const [k, v] of Object.entries(a.mcp)) merged.mcp[k] = (merged.mcp[k] ?? 0) + v;
-    for (const [k, v] of Object.entries(a.skills)) merged.skills[k] = (merged.skills[k] ?? 0) + v;
-    for (const [k, v] of Object.entries(a.web)) merged.web[k] = (merged.web[k] ?? 0) + v;
+    for (const kind of ['mcp', 'skills', 'web']) {
+      for (const [k, v] of Object.entries(a[kind] ?? {})) merged[kind][k] = (merged[kind][k] ?? 0) + v;
+    }
   }
   return merged;
 }
+
+function addBucket(into, from) {
+  into.calls += from.calls;
+  into.outputTokens += from.outputTokens;
+  into.contextTokens += from.contextTokens;
+  into.contextMissing += from.contextMissing;
+  for (const [m, n] of Object.entries(from.outputByModel)) into.outputByModel[m] = (into.outputByModel[m] ?? 0) + n;
+  for (const [m, u] of Object.entries(from.contextByModel)) {
+    const c = (into.contextByModel[m] ??= { input: 0, cacheWrite5m: 0, cacheWrite1h: 0 });
+    c.input += u.input;
+    c.cacheWrite5m += u.cacheWrite5m;
+    c.cacheWrite1h += u.cacheWrite1h;
+  }
+  for (const [s, n] of Object.entries(from.via)) into.via[s] = (into.via[s] ?? 0) + n;
+}
+
+export function mergeParsed(parsedList) {
+  const out = { mcp: {}, skills: {}, web: {} };
+  for (const p of parsedList) {
+    for (const [slug, server] of Object.entries(p.mcp ?? {})) {
+      const into = (out.mcp[slug] ??= { displayName: server.displayName, tools: {} });
+      for (const [tool, bucket] of Object.entries(server.tools)) addBucket((into.tools[tool] ??= newBucket()), bucket);
+    }
+    for (const [name, bucket] of Object.entries(p.skills ?? {})) addBucket((out.skills[name] ??= newBucket()), bucket);
+    for (const [k, v] of Object.entries(p.web ?? {})) out.web[k] = (out.web[k] ?? 0) + v;
+  }
+  return out;
+}