burner-cc 0.1.2 → 0.3.0

package/src/tag-end.js

@@ -0,0 +1,94 @@
+// SessionEnd hook: ask a small/fast model what the session was for, then tag it.
+
+import { readFileSync } from 'node:fs';
+import { discoverSessions } from './discover.js';
+import { parseTranscript } from './parse.js';
+import { loadConfig } from './config.js';
+import { loadTags, setTag, resolveSessionProject } from './tags.js';
+import { allowedCategories, buildDigest } from './classifier.js';
+
+export async function readHookPayload() {
+  try {
+    const chunks = [];
+    for await (const chunk of process.stdin) chunks.push(chunk);
+    const text = Buffer.concat(chunks).toString('utf-8').trim();
+    if (!text) return {};
+    return JSON.parse(text);
+  } catch {
+    return {};
+  }
+}
+
+function pickCategory(text, allowed) {
+  const t = String(text ?? '').toLowerCase();
+  for (const id of allowed) {
+    if (t === id || t.includes(id)) return id;
+  }
+  const word = t.match(/[a-z][a-z0-9_-]*/)?.[0];
+  if (word && allowed.includes(word)) return word;
+  return null;
+}
+
+async function classifyWithModel(digest, categories, model) {
+  const key = process.env.ANTHROPIC_API_KEY;
+  if (!key) throw new Error('ANTHROPIC_API_KEY is not set (needed for session-end tagging)');
+  const lines = categories.map((c) => `${c.id}: ${c.description || c.label}`).join('\n');
+  const prompts = (digest.prompts ?? []).slice(0, 6).map((p, i) => `${i + 1}. ${p}`).join('\n');
+  const tools = (digest.tools ?? []).slice(0, 8).map(([s, n]) => `${s} x${n}`).join(', ');
+  const user = `Pick exactly one category id for this Claude Code session.
+
+Categories (reply with only the id):
+${lines}
+
+Session title: ${digest.title ?? '—'}
+Project: ${digest.project ?? '—'}
+User prompts:
+${prompts || '(none)'}
+Tools used: ${tools || '(none)'}`;
+
+  const res = await fetch('https://api.anthropic.com/v1/messages', {
+    method: 'POST',
+    headers: {
+      'x-api-key': key,
+      'anthropic-version': '2023-06-01',
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify({ model, max_tokens: 40, messages: [{ role: 'user', content: user }] }),
+    signal: AbortSignal.timeout(45_000),
+  });
+  if (!res.ok) throw new Error(`Anthropic API ${res.status}: ${(await res.text()).slice(0, 300)}`);
+  const data = await res.json();
+  const text = data.content?.find((b) => b.type === 'text')?.text ?? '';
+  return text.trim();
+}
+
+export async function tagSessionAtEnd({ sessionId, model } = {}) {
+  const cfg = loadConfig();
+  const endModel = (model ?? cfg.tagging?.endModel ?? '').trim();
+  if (!endModel) return { ok: false, skipped: true, reason: 'no endModel configured' };
+
+  const id = sessionId ?? process.env.CLAUDE_SESSION_ID;
+  if (!id || id.includes('${')) return { ok: false, skipped: true, reason: 'no session id' };
+
+  const sessions = discoverSessions();
+  const s = sessions.find((x) => x.sessionId === id || x.sessionId.startsWith(id));
+  if (!s) return { ok: false, skipped: true, reason: 'session not found yet' };
+
+  const existing = loadTags()[s.sessionId];
+  if (existing && ['skill', 'manual'].includes(existing.source)) {
+    return { ok: true, skipped: true, reason: 'already tagged', category: existing.category };
+  }
+
+  const parsed = parseTranscript(s.mainFile);
+  const project = resolveSessionProject(s.sessionId, parsed.digest.cwd, cfg);
+  const allowed = allowedCategories(project, cfg);
+  const allowedIds = allowed.map((c) => c.id);
+  const digest = buildDigest(parsed, { title: s.customTitle ?? parsed.digest.aiTitle, projectName: project.name });
+
+  const answer = await classifyWithModel(digest, allowed, endModel);
+  const category = pickCategory(answer.split(/\r?\n/)[0], allowedIds);
+  if (!category) return { ok: false, error: `model answer not a category: ${answer.slice(0, 80)}` };
+
+  setTag(s.sessionId, { category, source: 'end-model', reason: answer.slice(0, 80) });
+  return { ok: true, sessionId: s.sessionId, category, model: endModel };
+}

package/src/tagging.js

@@ -0,0 +1,122 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { analyzeSessions } from './analyze.js';
+import { discoverSessions } from './discover.js';
+import { parseTranscript } from './parse.js';
+import { loadConfig } from './config.js';
+import { loadTags, setTag, resolveSessionProject } from './tags.js';
+import { allowedCategories, trainLearned, saveLearned, loadPrior } from './classifier.js';
+
+function samePath(a, b) {
+  const n = (p) => path.resolve(p).replace(/[\\/]+$/, '').toLowerCase();
+  return n(a) === n(b);
+}
+
+// The session a /burner-tag call came from. Claude Code substitutes
+// ${CLAUDE_SESSION_ID} in skills; when it doesn't, fall back to the newest
+// transcript whose working directory is this one.
+export function resolveCurrentSession(explicit, cwd = process.cwd()) {
+  const id = [explicit, process.env.CLAUDE_SESSION_ID].find((v) => v && !v.includes('${') && v.trim());
+  const sessions = discoverSessions();
+  if (id) {
+    const s = sessions.find((x) => x.sessionId === id || x.sessionId.startsWith(id));
+    if (s) return s;
+  }
+  for (const s of sessions.slice(0, 40)) {
+    const { digest } = parseTranscript(s.mainFile);
+    if (digest.cwd && samePath(digest.cwd, cwd)) return s;
+  }
+  return sessions[0] ?? null;
+}
+
+export function tagFromCli({ category, session, reason, task, source = 'skill' }) {
+  const cfg = loadConfig();
+  const s = resolveCurrentSession(session);
+  if (!s) throw new Error('no Claude Code sessions found');
+  const { digest } = parseTranscript(s.mainFile);
+  const project = resolveSessionProject(s.sessionId, digest.cwd, cfg);
+  const allowed = allowedCategories(project, cfg).map((c) => c.id);
+  if (!allowed.includes(category)) {
+    throw new Error(`"${category}" is not a category for project ${project.name}. Use one of: ${allowed.join(', ')}`);
+  }
+  const entry = setTag(s.sessionId, { category, source, reason, segment: !!task });
+  return { sessionId: s.sessionId, project: project.name, ...entry };
+}
+
+// SWE-chat (SALT-NLP) prompt_intent -> burner categories.
+export const SWE_CHAT_LABELS = {
+  'create new code': 'coding',
+  refactor: 'coding',
+  debug: 'debugging',
+  understand: 'research',
+  test: 'coding',
+  git: 'coding',
+  connect: 'coding',
+  other: 'other',
+};
+
+export async function fetchSweChat({ token, limit = 5000, onProgress } = {}) {
+  if (!token) throw new Error('SWE-chat is gated: accept its terms at https://huggingface.co/datasets/SALT-NLP/SWE-chat and set HF_TOKEN');
+  const where = encodeURIComponent('"prompt_intent" IS NOT NULL');
+  const rows = [];
+  for (let offset = 0; offset < limit; offset += 100) {
+    const url = `https://datasets-server.huggingface.co/filter?dataset=SALT-NLP/SWE-chat&config=default&split=train&where=${where}&offset=${offset}&length=100`;
+    const res = await fetch(url, { headers: { Authorization: `Bearer ${token}` }, signal: AbortSignal.timeout(60000) });
+    if (!res.ok) throw new Error(`SWE-chat fetch failed: HTTP ${res.status} ${(await res.text()).slice(0, 200)}`);
+    const data = await res.json();
+    for (const { row } of data.rows ?? []) {
+      const category = SWE_CHAT_LABELS[String(row.prompt_intent).toLowerCase()];
+      if (category && row.content) rows.push({ text: String(row.content).slice(0, 2000), category });
+    }
+    onProgress?.(rows.length);
+    if (!data.rows?.length || offset + 100 >= (data.num_rows_total ?? Infinity)) break;
+  }
+  return rows;
+}
+
+// Trains the learned model: user tags (weighted up - they're this user's
+// own work) plus any public prior examples ({ text, category }).
+export async function trainFromTags({ prior = [], localWeight = 5, bootstrapPrior = false } = {}) {
+  try {
+    const a = await analyzeSessions();
+    const tags = loadTags();
+    const examples = [];
+    for (const s of a.sessions) {
+      const t = tags[s.sessionId];
+      if (!t || !['skill', 'manual'].includes(t.source)) continue;
+      const digest = a.digests.get(s.sessionId);
+      if (!digest?.prompts?.length) continue;
+      examples.push({ digest, category: t.category, weight: localWeight, source: 'local' });
+    }
+    for (const p of prior) {
+      const text = String(p.text ?? '').trim();
+      if (!text) continue;
+      examples.push({ digest: { prompts: [text], tools: [] }, category: p.category, weight: 1, source: p.source ?? 'public' });
+    }
+    const classes = new Set(examples.map((e) => e.category));
+    if (examples.length < 6 || classes.size < 2) {
+      return { ok: false, examples: examples.length, message: `need at least 6 tagged sessions across 2+ categories to learn from (have ${examples.length})` };
+    }
+    const model = trainLearned(examples, { prior: bootstrapPrior ? loadPrior() : null });
+    saveLearned(model);
+    const localCount = examples.filter((e) => e.source === 'local').length;
+    return {
+      ok: true,
+      examples: localCount,
+      totalRows: model.examples,
+      sources: model.sources,
+      classes: Object.fromEntries(Object.entries(model.classes).map(([k, v]) => [k, v.docs])),
+    };
+  } catch (err) {
+    const code = err?.code;
+    if (code === 'EACCES' || code === 'EPERM') {
+      return { ok: false, message: `could not write model under ~/.burner (${code})` };
+    }
+    if (code === 'ENOSPC') return { ok: false, message: 'disk full — could not save model' };
+    return { ok: false, message: err?.message ?? String(err) };
+  }
+}
+
+export function readJsonl(file) {
+  return readFileSync(file, 'utf-8').split('\n').filter((l) => l.trim()).map((l) => JSON.parse(l));
+}

package/src/tags.js

@@ -0,0 +1,79 @@
+import { FILES, readJson, writeJson, resolveProject } from './config.js';
+
+// tags.json: { [sessionId]: { category, source, at, reason?, confidence?, model?, segments: [{ category, at, reason? }] } }
+//   source: skill | manual
+// A segment marks the end of one task inside a session ("Every task" level):
+// turns up to its timestamp belong to it.
+
+export function loadTags() {
+  return readJson(FILES.tags, {});
+}
+
+export function saveTags(tags) {
+  writeJson(FILES.tags, tags);
+}
+
+export function setTag(sessionId, { category, source, reason, confidence, model, segment = false, at }) {
+  const tags = loadTags();
+  const now = at ?? new Date().toISOString();
+  const prev = tags[sessionId];
+  const entry = prev && segment ? { ...prev } : { segments: [] };
+  entry.category = category;
+  entry.source = source;
+  entry.at = now;
+  if (reason) entry.reason = String(reason).slice(0, 300);
+  else delete entry.reason;
+  if (confidence != null) entry.confidence = confidence;
+  else delete entry.confidence;
+  if (model) entry.model = model;
+  else delete entry.model;
+  if (segment) entry.segments = [...(entry.segments ?? []), { category, at: now, ...(reason ? { reason: String(reason).slice(0, 300) } : {}) }];
+  tags[sessionId] = entry;
+  saveTags(tags);
+  return entry;
+}
+
+export function clearTag(sessionId) {
+  const tags = loadTags();
+  delete tags[sessionId];
+  saveTags(tags);
+}
+
+// Splits a session's turns across its task segments by timestamp.
+export function segmentTurns(turns, segments) {
+  if (!segments?.length) return null;
+  const segs = [...segments].sort((a, b) => String(a.at).localeCompare(String(b.at)));
+  const groups = segs.map((s) => ({ category: s.category, turns: [] }));
+  for (const t of turns) {
+    const ts = t.timestamp ?? '';
+    let idx = segs.findIndex((s) => ts <= s.at);
+    if (idx < 0) idx = segs.length - 1;
+    groups[idx].turns.push(t);
+  }
+  return groups;
+}
+
+// assignments.json: { [sessionId]: projectName }
+// Lets one session move into a project even though it was started somewhere
+// else (typically a home directory that holds work for several projects).
+export function loadAssignments() {
+  return readJson(FILES.assignments, {});
+}
+
+export function setAssignment(sessionId, projectName) {
+  const a = loadAssignments();
+  if (projectName) a[sessionId] = projectName;
+  else delete a[sessionId];
+  writeJson(FILES.assignments, a);
+}
+
+// The project a session belongs to: its own assignment if that project still
+// exists, otherwise whatever its working directory resolves to.
+export function resolveSessionProject(sessionId, cwd, cfg, assignments = loadAssignments()) {
+  const name = assignments[sessionId];
+  if (name) {
+    const p = cfg.projects.find((x) => x.name === name);
+    if (p) return { ...p, implicit: false, bySession: true };
+  }
+  return resolveProject(cwd, cfg);
+}

package/src/themes.js

@@ -0,0 +1,122 @@
+import { DEFAULT_CATEGORIES, UNTAGGED } from './config.js';
+
+const CAT_IDS = [...DEFAULT_CATEGORIES.map((c) => c.id), UNTAGGED.id];
+export const PAPER_CATEGORY_COLORS = Object.fromEntries(DEFAULT_CATEGORIES.map((c) => [c.id, c.color.toLowerCase()]));
+const PAPER_DEFAULT = PAPER_CATEGORY_COLORS;
+
+// Per-theme category hues tuned for contrast on each background.
+const PALETTES = {
+  paper: {
+    coding: '#2563eb',
+    debugging: '#dc2626',
+    planning: '#059669',
+    research: '#475569',
+    writing: '#b45309',
+    analysis: '#0d9488',
+    review: '#c2410c',
+    learning: '#64748b',
+    other: '#94a3b8',
+    untagged: '#a8a29e',
+  },
+  dark: {
+    coding: '#60a5fa',
+    debugging: '#f87171',
+    planning: '#4ade80',
+    research: '#94a3b8',
+    writing: '#fbbf24',
+    analysis: '#2dd4bf',
+    review: '#fb923c',
+    learning: '#cbd5e1',
+    other: '#9ca3af',
+    untagged: '#6b7280',
+  },
+  thermal: {
+    coding: '#1d4ed8',
+    debugging: '#b91c1c',
+    planning: '#047857',
+    research: '#57534e',
+    writing: '#a16207',
+    analysis: '#0f766e',
+    review: '#c2410c',
+    learning: '#78716c',
+    other: '#a8a29e',
+    untagged: '#a8a29e',
+  },
+  matrix: {
+    coding: '#22d3ee',
+    debugging: '#fb7185',
+    planning: '#4ade80',
+    research: '#86efac',
+    writing: '#fde047',
+    analysis: '#2dd4bf',
+    review: '#f97316',
+    learning: '#a3e635',
+    other: '#6ee7b7',
+    untagged: '#3f6212',
+  },
+};
+
+const SHARED = `
+  --accent-fg: var(--page-bg);
+  --warn: #dc2626;
+  --shadow: rgba(0,0,0,.12);
+  --shadow-lg: rgba(0,0,0,.22);
+`;
+
+function catVars(theme) {
+  const p = PALETTES[theme];
+  return CAT_IDS.map((id) => `--cat-${id}:${p[id]}`).join(';');
+}
+
+// Injected into report, receipt, and settings <style> blocks.
+export function themeCss() {
+  return `
+:root[data-theme="paper"]{
+  --bg:#f4f1e8;--ink:#2b2b26;--dim:#8a8478;--rule:#b8b2a2;--page-bg:#e7e2d3;
+  --accent:#2b2b26;--chart-bar:#b45309;--chart-bar-alt:#2563eb;
+  ${SHARED}${catVars('paper')}
+}
+:root[data-theme="dark"]{
+  --bg:#1c1f26;--ink:#e8eaed;--dim:#8b919c;--rule:#3d4450;--page-bg:#0f1115;
+  --accent:#e8eaed;--chart-bar:#fb923c;--chart-bar-alt:#60a5fa;
+  --warn:#f87171;--shadow:rgba(0,0,0,.45);--shadow-lg:rgba(0,0,0,.65);
+  ${catVars('dark')}
+}
+:root[data-theme="thermal"]{
+  --bg:#fdf6e3;--ink:#3d3424;--dim:#9a8b6e;--rule:#d4c4a0;--page-bg:#efe6c8;
+  --accent:#7c4a03;--chart-bar:#c2410c;--chart-bar-alt:#1d4ed8;
+  ${SHARED}${catVars('thermal')}
+}
+:root[data-theme="matrix"]{
+  --bg:#061408;--ink:#5efc8e;--dim:#2d6b3f;--rule:#1a4d2a;--page-bg:#020a04;
+  --accent:#7dffab;--chart-bar:#4ade80;--chart-bar-alt:#22d3ee;
+  --warn:#fb7185;--shadow:rgba(0,40,0,.5);--shadow-lg:rgba(0,60,0,.7);
+  ${catVars('matrix')}
+}`;
+}
+
+// User-edited category colors in config override the theme palette.
+export function categoryOverrideCss(categories) {
+  const lines = [];
+  for (const c of categories) {
+    const paper = PAPER_DEFAULT[c.id];
+    if (!paper || String(c.color).toLowerCase() === paper) continue;
+    lines.push(`--cat-${c.id}:${c.color}`);
+  }
+  if (!lines.length) return '';
+  return `:root{${lines.join(';')}}`;
+}
+
+export function resolveCategoryColor(theme, categoryId, storedColor) {
+  const paper = PAPER_DEFAULT[categoryId];
+  const stored = String(storedColor ?? '').toLowerCase();
+  if (paper && stored && stored !== paper) return storedColor;
+  return PALETTES[theme]?.[categoryId] ?? storedColor ?? '#888';
+}
+
+export function categoryColorsForTheme(theme, categories) {
+  const map = {};
+  for (const c of categories) map[c.id] = resolveCategoryColor(theme, c.id, c.color);
+  map[UNTAGGED.id] = resolveCategoryColor(theme, UNTAGGED.id, UNTAGGED.color);
+  return map;
+}

package/src/yaml.js

@@ -0,0 +1,163 @@
+// Minimal YAML for burner's own config files: block maps, block lists,
+// flow lists of scalars, quoted/plain scalars, comments. Not a general YAML
+// parser — anchors, multi-line strings and flow maps are not supported.
+
+function parseScalar(raw) {
+  const s = raw.trim();
+  if (s === '' || s === '~' || s === 'null') return null;
+  if (s === 'true') return true;
+  if (s === 'false') return false;
+  if (/^-?\d+(\.\d+)?([eE][-+]?\d+)?$/.test(s)) return Number(s);
+  if (s.startsWith('"')) return JSON.parse(s);
+  if (s.startsWith("'")) return s.slice(1, -1).replace(/''/g, "'");
+  if (s.startsWith('[') && s.endsWith(']')) {
+    const inner = s.slice(1, -1).trim();
+    return inner ? splitFlow(inner).map(parseScalar) : [];
+  }
+  if (s === '{}') return {};
+  return s;
+}
+
+function splitFlow(s) {
+  const out = [];
+  let cur = '';
+  let quote = null;
+  for (const ch of s) {
+    if (quote) {
+      cur += ch;
+      if (ch === quote) quote = null;
+    } else if (ch === '"' || ch === "'") {
+      quote = ch;
+      cur += ch;
+    } else if (ch === ',') {
+      out.push(cur);
+      cur = '';
+    } else {
+      cur += ch;
+    }
+  }
+  out.push(cur);
+  return out;
+}
+
+function stripComment(line) {
+  let quote = null;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (quote) {
+      if (ch === '\\' && quote === '"') i++;
+      else if (ch === quote) quote = null;
+    } else if (ch === '"' || ch === "'") quote = ch;
+    else if (ch === '#' && (i === 0 || /\s/.test(line[i - 1]))) return line.slice(0, i);
+  }
+  return line;
+}
+
+function splitKey(text) {
+  let quote = null;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (quote) {
+      if (ch === '\\' && quote === '"') i++;
+      else if (ch === quote) quote = null;
+    } else if (ch === '"' || ch === "'") quote = ch;
+    else if (ch === ':' && (i + 1 === text.length || text[i + 1] === ' ')) {
+      return [parseScalar(text.slice(0, i)), text.slice(i + 1)];
+    }
+  }
+  return null;
+}
+
+export function parseYaml(text) {
+  const lines = [];
+  for (const raw of text.replace(/\r\n/g, '\n').split('\n')) {
+    const line = stripComment(raw).replace(/\s+$/, '');
+    if (!line.trim()) continue;
+    lines.push({ indent: line.length - line.trimStart().length, text: line.trim() });
+  }
+  let i = 0;
+
+  function block(indent) {
+    if (i >= lines.length) return null;
+    return lines[i].text.startsWith('- ') || lines[i].text === '-' ? list(lines[i].indent) : map(lines[i].indent);
+  }
+
+  function valueAfter(rest, parentIndent) {
+    if (rest.trim() !== '') return parseScalar(rest);
+    if (i < lines.length && lines[i].indent > parentIndent) return block(lines[i].indent);
+    if (i < lines.length && lines[i].indent === parentIndent && lines[i].text.startsWith('- ')) return list(parentIndent);
+    return null;
+  }
+
+  function map(indent) {
+    const obj = {};
+    while (i < lines.length && lines[i].indent === indent && !lines[i].text.startsWith('- ')) {
+      const kv = splitKey(lines[i].text);
+      if (!kv) throw new Error(`yaml: expected "key: value" at "${lines[i].text}"`);
+      i++;
+      obj[kv[0]] = valueAfter(kv[1], indent);
+    }
+    return obj;
+  }
+
+  function list(indent) {
+    const arr = [];
+    while (i < lines.length && lines[i].indent === indent && (lines[i].text.startsWith('- ') || lines[i].text === '-')) {
+      const rest = lines[i].text.slice(1).trimStart();
+      const kv = rest ? splitKey(rest) : null;
+      if (kv) {
+        // "- key: value" opens a map whose remaining keys sit at the item's content column.
+        const childIndent = indent + (lines[i].text.length - rest.length);
+        lines[i] = { indent: childIndent, text: rest };
+        arr.push(map(childIndent));
+      } else {
+        i++;
+        arr.push(valueAfter(rest, indent));
+      }
+    }
+    return arr;
+  }
+
+  return block(0) ?? {};
+}
+
+const PLAIN = /^[A-Za-z_][A-Za-z0-9_.\-/ ]*$/;
+const RESERVED = /^(true|false|null|~|yes|no|on|off)$/i;
+
+function scalar(v) {
+  if (v === null || v === undefined) return 'null';
+  if (typeof v === 'number' || typeof v === 'boolean') return String(v);
+  const s = String(v);
+  if (PLAIN.test(s) && !RESERVED.test(s) && !s.endsWith(' ')) return s;
+  return JSON.stringify(s);
+}
+
+function isScalar(v) {
+  return v === null || typeof v !== 'object';
+}
+
+export function stringifyYaml(value, indent = 0) {
+  const pad = ' '.repeat(indent);
+  if (Array.isArray(value)) {
+    if (!value.length) return '[]';
+    return value.map((item) => {
+      if (isScalar(item)) return `${pad}- ${scalar(item)}`;
+      if (Array.isArray(item)) return `${pad}-\n${stringifyYaml(item, indent + 2)}`;
+      const body = stringifyYaml(item, indent + 2);
+      return `${pad}- ${body.slice(indent + 2)}`;
+    }).join('\n');
+  }
+  const entries = Object.entries(value ?? {}).filter(([, v]) => v !== undefined);
+  if (!entries.length) return `${pad}{}`;
+  return entries.map(([k, v]) => {
+    const key = scalar(k);
+    if (isScalar(v)) return `${pad}${key}: ${scalar(v)}`;
+    if (Array.isArray(v)) {
+      if (!v.length) return `${pad}${key}: []`;
+      if (v.every(isScalar) && v.length <= 12) return `${pad}${key}: [${v.map(scalar).join(', ')}]`;
+      return `${pad}${key}:\n${stringifyYaml(v, indent + 2)}`;
+    }
+    if (!Object.keys(v).length) return `${pad}${key}: {}`;
+    return `${pad}${key}:\n${stringifyYaml(v, indent + 2)}`;
+  }).join('\n');
+}