ok-claude 0.1.0

package/dist/cli.js

@@ -0,0 +1,1065 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import open from "open";
+
+// src/pipeline.ts
+import { writeFile } from "fs/promises";
+import { statSync } from "fs";
+import { homedir as homedir2, userInfo } from "os";
+import { join as join2, resolve } from "path";
+import { execSync } from "child_process";
+
+// src/discover.ts
+import { readdir, stat } from "fs/promises";
+import { homedir } from "os";
+import { join, sep } from "path";
+function logsRoot() {
+  return join(homedir(), ".claude", "projects");
+}
+var SUBAGENT_SEG = `${sep}subagents${sep}`;
+async function discoverLogs() {
+  const root = logsRoot();
+  const paths = [];
+  try {
+    const entries = await readdir(root, {
+      recursive: true,
+      withFileTypes: true
+    });
+    for (const e of entries) {
+      if (!e.isFile()) continue;
+      if (!e.name.endsWith(".jsonl")) continue;
+      const full = join(e.parentPath, e.name);
+      if (full.includes(SUBAGENT_SEG)) continue;
+      paths.push(full);
+    }
+  } catch (err) {
+    if (err.code === "ENOENT") return [];
+    throw err;
+  }
+  paths.sort();
+  const out = [];
+  for (const p of paths) {
+    try {
+      const s = await stat(p);
+      out.push({ path: p, size: s.size });
+    } catch {
+    }
+  }
+  return out;
+}
+
+// src/stream.ts
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+
+// src/parse.ts
+var PROSE_TYPES = /* @__PURE__ */ new Set(["user", "assistant"]);
+function dropReason(raw) {
+  if (raw.type !== void 0 && !PROSE_TYPES.has(raw.type)) return "non-prose-type";
+  if (raw.isMeta === true) return "isMeta";
+  if (raw.isSidechain === true) return "isSidechain";
+  if (raw.isApiErrorMessage === true) return "isApiErrorMessage";
+  if (raw.isCompactSummary === true) return "isCompactSummary";
+  if (raw.isVisibleInTranscriptOnly === true) return "isVisibleInTranscriptOnly";
+  const role = raw.message?.role;
+  if (role !== "user" && role !== "assistant") return "non-prose-role";
+  return null;
+}
+function extractText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  let out = "";
+  for (const block of content) {
+    if (block && block.type === "text" && typeof block.text === "string") {
+      out += block.text;
+    }
+  }
+  return out;
+}
+var HARNESS_TAGS = [
+  "system-reminder",
+  "command-name",
+  "command-message",
+  "command-args",
+  "local-command-stdout",
+  "local-command-stderr",
+  "task-notification",
+  "bash-input",
+  "bash-stdout",
+  "bash-stderr"
+];
+var HARNESS_TAG_RE = new RegExp(
+  `<(${HARNESS_TAGS.join("|")})\\b[^>]*>[\\s\\S]*?<\\/\\1>`,
+  "g"
+);
+function stripHarnessTags(text) {
+  return text.replace(HARNESS_TAG_RE, "");
+}
+function parseLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  let raw;
+  try {
+    raw = JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+  if (dropReason(raw) !== null) return null;
+  const role = raw.message.role;
+  const rawText = extractText(raw.message?.content);
+  const text = stripHarnessTags(rawText);
+  if (!text.trim()) return null;
+  const event = { role, text };
+  if (typeof raw.timestamp === "string") event.timestamp = raw.timestamp;
+  const usage = raw.message?.usage;
+  if (usage && typeof usage.input_tokens === "number") {
+    event.tokensIn = usage.input_tokens;
+  }
+  if (usage && typeof usage.output_tokens === "number") {
+    event.tokensOut = usage.output_tokens;
+  }
+  return event;
+}
+
+// src/stream.ts
+async function* streamEvents(files, onProgress) {
+  let bytesDone = 0;
+  for (let i = 0; i < files.length; i++) {
+    const entry = files[i];
+    try {
+      const rl = createInterface({
+        input: createReadStream(entry.path, { encoding: "utf8" }),
+        crlfDelay: Infinity
+      });
+      for await (const line of rl) {
+        const e = parseLine(line);
+        if (e) yield e;
+      }
+    } catch (err) {
+      process.stderr.write(
+        `ok-claude: skipped ${entry.path}: ${err.message}
+`
+      );
+    }
+    bytesDone += entry.size;
+    onProgress(bytesDone, i + 1);
+  }
+}
+
+// src/denoise.ts
+var FENCED_BLOCK = /```[\s\S]*?```/g;
+var UNTERMINATED_FENCE = /```[\s\S]*$/;
+var INLINE_BACKTICK = /`[^`\n]*`/g;
+var STACK_FRAME_SINGLE = /\bat\s+[\w.<>$]+\s*\([^)]*[/\\][^)]*:\d+(?::\d+)?\)/g;
+var WIN_PATH = /[A-Za-z]:\\[\w\\.\-]+/g;
+var URL_PATTERN = /\bhttps?:\/\/[^\s)\]"'<>]+/g;
+var PATH_WITH_EXT = /\b[\w.\-]+(?:[\\/][\w.\-]+)+\.[a-zA-Z]\w*\b/g;
+var DEEP_PATH = /\b[\w.\-]{2,}[\\/][\w.\-]{2,}(?:[\\/][\w.\-]+){1,}/g;
+var N_CLITIC = new RegExp("(\\p{L})n['\u2019]t\\b", "giu");
+var CLITIC = new RegExp("(\\p{L})['\u2019](?:s|d|m|re|ve|ll)\\b", "giu");
+function denoiseMarkdown(text) {
+  if (!text) return text;
+  let out = text.replace(FENCED_BLOCK, " ");
+  out = out.replace(UNTERMINATED_FENCE, " ");
+  out = stripIndentedBlocks(out);
+  out = stripLongStructuredLines(out);
+  out = stripNonFencedPasteBlocks(out);
+  out = out.replace(INLINE_BACKTICK, " ");
+  out = out.replace(STACK_FRAME_SINGLE, " ");
+  out = out.replace(URL_PATTERN, " ");
+  out = out.replace(WIN_PATH, " ");
+  out = out.replace(PATH_WITH_EXT, " ");
+  out = out.replace(DEEP_PATH, " ");
+  out = out.replace(N_CLITIC, "$1");
+  out = out.replace(CLITIC, "$1");
+  return out;
+}
+var STACK_FRAME_LINE = /^\s*(at\s+\S+\.|File\s+["'].+["'],\s*line\s+\d+)/;
+var TS_TYPE_ERROR = /Type\s+'[^']+'\s+is\s+not\s+assignable|error\s+TS\d{4}:|NullReferenceException/;
+var IDENT_DOT = /[a-z][a-zA-Z0-9]+\.[a-z][a-zA-Z0-9]|[A-Z][a-zA-Z0-9]+\.[A-Z][a-zA-Z0-9]/;
+var ERROR_CLASS = /[A-Z][a-zA-Z]+(Error|Exception)\b/;
+var NATIVE_JIT_FRAME = /^0x[0-9a-fA-F]+\s+\((?:Mono|Unity|UnityEditor|UnityEngine|UnityPlayer)\b/;
+var BUILD_WARNING = /^(?:WARNING:|ERROR:|FAILURE:|> (?:Task|Configure project)|BUILD FAILED)\b/;
+var STRUCT_CHARS = new Set(`{}[]():,;"='|<>`);
+var STRUCT_DENSITY_THRESHOLD = 0.22;
+var STRUCT_MIN_LINE_LEN = 20;
+var STRUCT_INLINE_MIN_LEN = 200;
+var JSON_KEY_PATTERN = /"\w+":/g;
+var JSON_KEY_ANCHOR_MIN = 3;
+function stripLongStructuredLines(text) {
+  const lines = text.split("\n");
+  return lines.map((l) => {
+    const nws = l.replace(/\s/g, "");
+    if (nws.length < STRUCT_INLINE_MIN_LEN) return l;
+    const keyHits = (l.match(JSON_KEY_PATTERN) ?? []).length;
+    if (keyHits >= JSON_KEY_ANCHOR_MIN) return "";
+    let hits = 0;
+    for (const c of nws) if (STRUCT_CHARS.has(c)) hits++;
+    return hits / nws.length >= STRUCT_DENSITY_THRESHOLD ? "" : l;
+  }).join("\n");
+}
+function looksLikeStructuredLine(line) {
+  const nws = line.replace(/\s/g, "");
+  if (nws.length < STRUCT_MIN_LINE_LEN) return false;
+  let hits = 0;
+  for (const c of nws) if (STRUCT_CHARS.has(c)) hits++;
+  return hits / nws.length >= STRUCT_DENSITY_THRESHOLD;
+}
+function looksLikeStackOrError(line) {
+  if (STACK_FRAME_LINE.test(line)) return true;
+  if (TS_TYPE_ERROR.test(line)) return true;
+  if (NATIVE_JIT_FRAME.test(line)) return true;
+  if (BUILD_WARNING.test(line)) return true;
+  if (looksLikeStructuredLine(line)) return true;
+  const tokens = line.split(/\s+/).filter((t) => t.length > 1);
+  if (tokens.length < 3) return false;
+  let hits = 0;
+  for (const t of tokens) {
+    if (IDENT_DOT.test(t) || ERROR_CLASS.test(t)) hits++;
+  }
+  return hits * 2 >= tokens.length;
+}
+function stripNonFencedPasteBlocks(text) {
+  const lines = text.split("\n");
+  const out = [];
+  let i = 0;
+  while (i < lines.length) {
+    let j = i;
+    while (j < lines.length && looksLikeStackOrError(lines[j])) j++;
+    if (j - i >= 3) {
+      i = j;
+      continue;
+    }
+    out.push(lines[i]);
+    i++;
+  }
+  return out.join("\n");
+}
+function stripIndentedBlocks(text) {
+  const lines = text.split("\n");
+  const kept = [];
+  let prevBlank = true;
+  let inBlock = false;
+  for (const line of lines) {
+    const isIndented = /^(?: {4}|\t)/.test(line);
+    const isBlank = line.trim() === "";
+    if (inBlock) {
+      if (isIndented || isBlank) {
+        continue;
+      }
+      inBlock = false;
+    }
+    if (prevBlank && isIndented) {
+      inBlock = true;
+      continue;
+    }
+    kept.push(line);
+    prevBlank = isBlank;
+  }
+  return kept.join("\n");
+}
+
+// src/tokenize.ts
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "is",
+  "are",
+  "was",
+  "were",
+  "of",
+  "to",
+  "in",
+  "on",
+  "at",
+  "for",
+  "and",
+  "or",
+  "but",
+  "i",
+  "you",
+  "it",
+  "this",
+  "that",
+  "with",
+  "as",
+  "be",
+  "by",
+  "from",
+  "if",
+  "so",
+  "not",
+  "do",
+  "does",
+  "did",
+  "have",
+  "has",
+  "had",
+  "will",
+  "would",
+  "can",
+  "could",
+  "should",
+  "just",
+  "like",
+  "get",
+  "got",
+  // n't-clitic survivors (BUG-004): won't → "wo", can't → "ca"
+  "wo",
+  "ca"
+]);
+var CJK_SCRIPT = /^[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]+$/u;
+var SHORT_LATIN_KEEP = /* @__PURE__ */ new Set(["y", "n", "k"]);
+var segmenter = new Intl.Segmenter(void 0, { granularity: "word" });
+function tokenize(text) {
+  if (!text) return [];
+  const out = [];
+  for (const seg of segmenter.segment(text)) {
+    if (!seg.isWordLike) continue;
+    const lower = seg.segment.toLocaleLowerCase();
+    const isCjk = CJK_SCRIPT.test(lower);
+    if (!isCjk && [...lower].length < 2 && !SHORT_LATIN_KEEP.has(lower))
+      continue;
+    if (/^\d+$/.test(lower)) continue;
+    if (STOPWORDS.has(lower)) continue;
+    out.push(lower);
+  }
+  return out;
+}
+
+// src/aggregate.ts
+function foldOpener(map, op) {
+  let inner = map.get(op.key);
+  if (!inner) {
+    inner = /* @__PURE__ */ new Map();
+    map.set(op.key, inner);
+  }
+  inner.set(op.surface, (inner.get(op.surface) ?? 0) + 1);
+}
+function topNOpeners(map, n) {
+  const entries = [];
+  for (const [, surfaceMap] of map) {
+    let total = 0;
+    let bestSurface = "";
+    let bestCount = -1;
+    for (const [surface, count] of surfaceMap) {
+      total += count;
+      if (count > bestCount || count === bestCount && surface < bestSurface) {
+        bestCount = count;
+        bestSurface = surface;
+      }
+    }
+    entries.push({ display: bestSurface, count: total });
+  }
+  entries.sort((a, b) => {
+    if (b.count !== a.count) return b.count - a.count;
+    return a.display < b.display ? -1 : a.display > b.display ? 1 : 0;
+  });
+  return entries.slice(0, n);
+}
+
+// src/openers.ts
+var TRAILING_PUNCT = /[.,!?;:。、！？]+$/u;
+var segmenter2 = new Intl.Segmenter(void 0, { granularity: "word" });
+function firstOpener(text) {
+  if (!text) return null;
+  for (const seg of segmenter2.segment(text)) {
+    if (!seg.isWordLike) continue;
+    const surface = seg.segment.replace(TRAILING_PUNCT, "");
+    if (!surface) continue;
+    const key = surface.toLocaleLowerCase().replace(TRAILING_PUNCT, "");
+    if (!key) continue;
+    return { key, surface };
+  }
+  return null;
+}
+
+// src/render.ts
+import { readFileSync } from "fs";
+var VENDOR_JS = readFileSync(
+  new URL("./vendor/wordcloud2.js", import.meta.url),
+  "utf8"
+);
+var HTML_TO_IMAGE_JS = readFileSync(
+  new URL("./vendor/html-to-image.js", import.meta.url),
+  "utf8"
+);
+function fontB64(name) {
+  return readFileSync(
+    new URL(`./vendor/fonts/${name}`, import.meta.url)
+  ).toString("base64");
+}
+var FONT_CSS = `
+@font-face {
+  font-family: 'Anton';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(data:font/woff2;base64,${fontB64("anton-400.woff2")}) format('woff2');
+}
+@font-face {
+  font-family: 'Archivo Narrow';
+  font-style: normal;
+  font-weight: 100 900;
+  font-display: swap;
+  src: url(data:font/woff2;base64,${fontB64("archivo-narrow.woff2")}) format('woff2');
+}
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 100 900;
+  font-display: swap;
+  src: url(data:font/woff2;base64,${fontB64("inter.woff2")}) format('woff2');
+}
+@font-face {
+  font-family: 'JetBrains Mono';
+  font-style: normal;
+  font-weight: 100 900;
+  font-display: swap;
+  src: url(data:font/woff2;base64,${fontB64("jetbrains-mono.woff2")}) format('woff2');
+}
+`;
+function safeJson(value) {
+  return JSON.stringify(value).replace(/<\/(script)/gi, "<\\/$1");
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function fmtTokens(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+  return String(n);
+}
+function computeDays(range) {
+  if (!range) return 30;
+  const start = new Date(range[0]).getTime();
+  const end = new Date(range[1]).getTime();
+  if (!Number.isFinite(start) || !Number.isFinite(end)) return 30;
+  return Math.max(1, Math.round((end - start) / 864e5));
+}
+function renderHtml(input) {
+  const dataJson = safeJson({
+    topUser: input.topUser,
+    topClaude: input.topClaude,
+    meta: input.meta
+  });
+  const burned = input.meta.tokensOut;
+  const days = computeDays(input.meta.dateRange);
+  const perDay = Math.round(burned / days);
+  const burnedTxt = escapeHtml(`${fmtTokens(burned)} tokens`);
+  const daysTxt = escapeHtml(`${days} days`);
+  const perDayTxt = escapeHtml(`${fmtTokens(perDay)} tokens`);
+  const msgCountTxt = escapeHtml(input.meta.messages.toLocaleString("en-US"));
+  const usernameTxt = escapeHtml(input.meta.username || "you");
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<title>OK Claude</title>
+<style>
+${FONT_CSS}
+  :root {
+    --paper: #0d0d0a;
+    --ink-1: #f4f1ea;
+    --ink-2: #8a857c;
+    --ink-3: #3a3a35;
+    --amber: #d97757;
+    --rule: #f4f1ea;
+    --s: 1;
+  }
+  * { box-sizing: border-box; margin: 0; padding: 0; }
+  html, body { width: 100%; height: 100%; overflow: hidden; }
+  body {
+    background: #050505;
+    font-family: 'Archivo Narrow', sans-serif;
+    color: var(--ink-1);
+  }
+  .page {
+    width: 100vw; height: 100vh;
+    display: flex; flex-direction: row;
+    align-items: center; justify-content: center;
+    gap: 24px; padding: 24px;
+  }
+  .stage {
+    width: calc(1080px * var(--s));
+    height: calc(1080px * var(--s));
+    flex: 0 0 auto;
+  }
+  .artifact {
+    width: 1080px; height: 1080px;
+    transform: scale(var(--s));
+    transform-origin: top left;
+    background:
+      radial-gradient(ellipse at 20% 10%, rgba(255,255,255,0.025), transparent 50%),
+      radial-gradient(ellipse at 80% 90%, rgba(255,255,255,0.03), transparent 50%),
+      var(--paper);
+    color: var(--ink-1);
+    display: flex; flex-direction: column;
+    padding: 52px 56px 44px;
+    position: relative;
+  }
+
+  .hdr-top {
+    text-align: left;
+    font-family: 'Anton', sans-serif;
+    font-size: 64px;
+    line-height: 1.0;
+    letter-spacing: -0.005em;
+    text-transform: uppercase;
+    color: var(--ink-1);
+    white-space: nowrap;
+  }
+  .hdr-top .num  { color: var(--amber); }
+  .hdr-top .ok   { text-transform: lowercase; color: var(--ink-2); }
+  .hdr-bot {
+    margin-top: 14px;
+    text-align: center;
+    font-family: 'Archivo Narrow', sans-serif;
+    font-size: 22px;
+    font-weight: 500;
+    text-transform: lowercase;
+    color: var(--ink-2);
+    letter-spacing: 0.01em;
+  }
+  .hdr-bot .num {
+    color: var(--ink-1);
+    font-weight: 700;
+    border-bottom: 2px solid var(--ink-1);
+    padding-bottom: 1px;
+  }
+  .hdr-bot .handle {
+    font-family: 'JetBrains Mono', monospace;
+    color: var(--ink-1);
+    font-weight: 700;
+    text-transform: none;
+    letter-spacing: 0;
+  }
+  .hdr-rule {
+    margin-top: 24px;
+    height: 4px; background: var(--ink-1);
+    position: relative;
+  }
+  .hdr-rule::after {
+    content: ''; position: absolute; top: 7px; left: 0; right: 0;
+    height: 1px; background: var(--ink-1);
+  }
+
+  .labels {
+    display: grid; grid-template-columns: 1fr 1fr;
+    margin-top: 28px;
+    font-family: 'Archivo Narrow', sans-serif;
+    font-size: 17px;
+    font-weight: 500;
+    color: var(--ink-2);
+    text-transform: lowercase;
+    letter-spacing: 0.01em;
+  }
+  .labels .l { text-align: left; }
+  .labels .r { text-align: left; padding-left: 14px; color: var(--ink-1); }
+  .labels .n { color: var(--amber); font-weight: 700; }
+
+  .halves {
+    flex: 1 1 auto;
+    margin-top: 14px;
+    display: grid; grid-template-columns: 1fr 1fr;
+    position: relative;
+    overflow: hidden;
+  }
+  .divider {
+    position: absolute; left: 50%; top: 0; bottom: 0;
+    width: 2px; background: var(--ink-1);
+    transform: translateX(-50%);
+  }
+  .half { position: relative; overflow: hidden; }
+  .half.claude { padding-left: 14px; }
+  .cv { width: 100%; height: 100%; display: block; }
+
+  .footer {
+    margin-top: 14px;
+    display: grid;
+    grid-template-columns: 1fr auto 1fr;
+    align-items: baseline;
+    border-top: 1px solid var(--ink-1);
+    padding-top: 12px;
+  }
+  .footer .cta {
+    grid-column: 2;
+    justify-self: center;
+    font-family: 'JetBrains Mono', monospace;
+    font-size: 16px;
+    color: var(--ink-1);
+    font-weight: 700;
+  }
+  .footer .cta .chev { color: var(--amber); margin-right: 4px; }
+  .footer .cta .cmt { color: var(--ink-2); font-weight: 400; }
+  .footer .byline {
+    grid-column: 3;
+    justify-self: end;
+    font-family: 'JetBrains Mono', monospace;
+    font-size: 16px;
+    color: var(--ink-2);
+    font-weight: 400;
+    white-space: nowrap;
+  }
+
+  .chrome {
+    flex: 0 0 auto;
+    display: flex; flex-direction: column;
+    align-items: stretch; gap: 14px;
+    min-width: 160px;
+  }
+  .actions { display: flex; flex-direction: column; gap: 12px; }
+  .btn {
+    font-family: 'JetBrains Mono', monospace;
+    font-weight: 700;
+    font-size: 16px;
+    text-transform: uppercase;
+    letter-spacing: 0.04em;
+    color: var(--ink-1);
+    background: transparent;
+    border: 1px solid var(--ink-1);
+    padding: 10px 18px;
+    cursor: pointer;
+    transition: background 120ms ease;
+    white-space: nowrap;
+  }
+  .btn:hover { background: rgba(244, 241, 234, 0.06); }
+  .btn .chev { margin-right: 6px; color: var(--ink-1); }
+  .btn-primary .chev { color: var(--amber); }
+  .toast {
+    font-family: 'Archivo Narrow', sans-serif;
+    font-size: 14px;
+    color: var(--ink-2);
+    text-transform: lowercase;
+    letter-spacing: 0.04em;
+    opacity: 0;
+    transition: opacity 200ms ease;
+    min-height: 1em;
+    text-align: center;
+  }
+  .toast.visible { opacity: 1; }
+
+  @media (max-aspect-ratio: 1/1) {
+    .page { flex-direction: column; }
+    .chrome { min-width: 0; align-items: center; }
+    .actions { flex-direction: row; gap: 16px; }
+  }
+</style>
+</head>
+<body>
+  <div class="page">
+    <div class="stage">
+      <div id="artifact" class="artifact">
+        <div class="hdr-top">
+          <span class="ok">ok.</span> CLAUDE:
+          <span class="num">${burnedTxt}</span> burned in <span class="num">${daysTxt}</span>.
+        </div>
+        <div class="hdr-bot"><span class="handle">@${usernameTxt}</span> &middot; avg <span class="num">${perDayTxt}</span>/day.</div>
+        <div class="hdr-rule"></div>
+
+        <div class="labels">
+          <div class="l">this is what you dump across <span class="n">${msgCountTxt}</span> messages:</div>
+          <div class="r">and this is what claude response:</div>
+        </div>
+
+        <div class="halves">
+          <div class="divider"></div>
+          <div class="half user"><canvas id="canvas-user" class="cv"></canvas></div>
+          <div class="half claude"><canvas id="canvas-claude" class="cv"></canvas></div>
+        </div>
+
+        <div class="footer">
+          <div class="cta"><span class="chev">&#9656;</span>npx ok-claude<span class="cmt"> # confess yours</span></div>
+          <div class="byline">by rocky hong</div>
+        </div>
+      </div>
+    </div>
+
+    <div class="chrome">
+      <div class="actions">
+        <button type="button" id="btn-download" class="btn btn-primary">
+          <span class="chev">&#9656;</span>DOWNLOAD
+        </button>
+        <button type="button" id="btn-copy" class="btn" title="copy image to clipboard">
+          <span class="chev">&#9656;</span>COPY
+        </button>
+      </div>
+      <div class="toast" id="toast"></div>
+    </div>
+  </div>
+
+<script>window.__DATA__ = ${dataJson};</script>
+<script>
+${VENDOR_JS}
+</script>
+<script>
+${HTML_TO_IMAGE_JS}
+</script>
+<script>
+(function boot() {
+  var DATA = window.__DATA__ || { topUser: [], topClaude: [], meta: {} };
+  var toastTimer = null;
+
+  function setupCanvas(canvas) {
+    var wrap = canvas.parentElement;
+    var dpr = window.devicePixelRatio || 1;
+    canvas.width = Math.max(1, Math.round(wrap.clientWidth * dpr));
+    canvas.height = Math.max(1, Math.round(wrap.clientHeight * dpr));
+    canvas.style.width = wrap.clientWidth + 'px';
+    canvas.style.height = wrap.clientHeight + 'px';
+  }
+
+  function logScale(entries, fontMin, fontMax) {
+    var max = entries[0][1];
+    var min = entries[entries.length - 1][1];
+    return function (count) {
+      if (max === min) return (fontMin + fontMax) / 2;
+      return fontMin + (fontMax - fontMin) * (Math.log(count) - Math.log(min)) / (Math.log(max) - Math.log(min));
+    };
+  }
+
+  function drawHalf(canvasId, rawEntries, opts) {
+    var canvas = document.getElementById(canvasId);
+    if (!canvas) return;
+    setupCanvas(canvas);
+    if (!rawEntries || rawEntries.length === 0) return;
+    var dpr = window.devicePixelRatio || 1;
+    var entries = rawEntries.map(function (pair) {
+      return [opts.caseFn ? opts.caseFn(pair[0]) : pair[0], pair[1]];
+    });
+    var cw = canvas.width, ch = canvas.height;
+    var innerEdgePx = 24 * dpr;
+    var origin = opts.side === 'user'
+      ? [cw - innerEdgePx, ch / 2]
+      : [innerEdgePx, ch / 2];
+    WordCloud(canvas, {
+      list: entries,
+      fontFamily: opts.fontFamily,
+      fontWeight: opts.fontWeight || 'normal',
+      color: opts.color,
+      backgroundColor: 'rgba(0,0,0,0)',
+      gridSize: 6,
+      weightFactor: logScale(entries, opts.fontMin * dpr, opts.fontMax * dpr),
+      rotateRatio: opts.rotateRatio,
+      minRotation: -Math.PI / 9,
+      maxRotation:  Math.PI / 9,
+      rotationSteps: 0,
+      shuffle: false,
+      shrinkToFit: true,
+      drawOutOfBound: false,
+      origin: origin,
+    });
+  }
+
+  function fitHeadline() {
+    var el = document.querySelector('.hdr-top');
+    if (!el) return;
+    var size = 88;
+    el.style.fontSize = size + 'px';
+    var guard = 120;
+    while (el.scrollWidth > el.clientWidth && size > 24 && guard-- > 0) {
+      size -= 1;
+      el.style.fontSize = size + 'px';
+    }
+  }
+
+  var INTER_STACK = '"Inter", system-ui, -apple-system, "Helvetica Neue", Helvetica, Arial, sans-serif';
+  function upper(s) { return s.toUpperCase(); }
+
+  function renderAll() {
+    fitHeadline();
+    drawHalf('canvas-user', DATA.topUser || [], {
+      side: 'user',
+      fontFamily: INTER_STACK,
+      fontWeight: '800',
+      color: '#f4f1ea',
+      fontMin: 16, fontMax: 240,
+      rotateRatio: 0.35,
+      caseFn: upper,
+    });
+    drawHalf('canvas-claude', DATA.topClaude || [], {
+      side: 'claude',
+      fontFamily: INTER_STACK,
+      fontWeight: '800',
+      color: '#d97757',
+      fontMin: 16, fontMax: 200,
+      rotateRatio: 0,
+      caseFn: upper,
+    });
+  }
+
+  function fitStage() {
+    var chrome = document.querySelector('.chrome');
+    if (!chrome) return;
+    var landscape = window.innerWidth > window.innerHeight;
+    var padding = 24, gap = 24;
+    var availW, availH;
+    if (landscape) {
+      availW = window.innerWidth - padding * 2 - gap - chrome.offsetWidth;
+      availH = window.innerHeight - padding * 2;
+    } else {
+      availW = window.innerWidth - padding * 2;
+      availH = window.innerHeight - padding * 2 - gap - chrome.offsetHeight;
+    }
+    var s = Math.max(0.05, Math.min(availW, availH) / 1080);
+    document.documentElement.style.setProperty('--s', String(s));
+  }
+
+  function showToast(msg) {
+    var el = document.getElementById('toast');
+    if (!el) return;
+    el.textContent = msg;
+    el.classList.add('visible');
+    if (toastTimer) clearTimeout(toastTimer);
+    toastTimer = setTimeout(function () {
+      el.classList.remove('visible');
+    }, 2500);
+  }
+
+  function captureBlob() {
+    var node = document.getElementById('artifact');
+    return window.htmlToImage.toBlob(node, {
+      pixelRatio: 2,
+      backgroundColor: '#0d0d0a',
+      cacheBust: true,
+      style: { transform: 'none' },
+    });
+  }
+
+  function downloadPng() {
+    captureBlob().then(function (blob) {
+      if (!blob) { showToast('download failed'); return; }
+      var stamp = (DATA.meta && DATA.meta.timestamp) || 'unstamped';
+      var name = 'ok-claude-result-' + stamp + '.png';
+      var url = URL.createObjectURL(blob);
+      var a = document.createElement('a');
+      a.href = url; a.download = name;
+      document.body.appendChild(a);
+      a.click();
+      a.remove();
+      setTimeout(function () { URL.revokeObjectURL(url); }, 1000);
+      showToast('saved ' + name);
+    }).catch(function () { showToast('download failed'); });
+  }
+
+  function copyPng() {
+    if (typeof ClipboardItem === 'undefined' || !navigator.clipboard || !navigator.clipboard.write) {
+      showToast('copy not supported \u2014 try download instead');
+      return;
+    }
+    captureBlob().then(function (blob) {
+      if (!blob) {
+        showToast('copy failed');
+        return Promise.reject('capture_failed');
+      }
+      return navigator.clipboard.write([new ClipboardItem({ 'image/png': blob })]);
+    }).then(function () {
+      showToast('copied to clipboard');
+    }).catch(function (reason) {
+      if (reason !== 'capture_failed') {
+        showToast('copy not supported \u2014 try download instead');
+      }
+    });
+  }
+
+  function whenFontsReady(cb) {
+    if (document.fonts && document.fonts.ready) {
+      document.fonts.ready.then(cb);
+    } else {
+      cb();
+    }
+  }
+
+  window.addEventListener('load', function () {
+    fitStage();
+    whenFontsReady(function () {
+      requestAnimationFrame(function () {
+        requestAnimationFrame(function () {
+          renderAll();
+        });
+      });
+    });
+    var dl = document.getElementById('btn-download');
+    var cp = document.getElementById('btn-copy');
+    if (dl) dl.addEventListener('click', downloadPng);
+    if (cp) cp.addEventListener('click', copyPng);
+  });
+  window.addEventListener('resize', function () {
+    clearTimeout(window.__rz);
+    window.__rz = setTimeout(fitStage, 60);
+  });
+})();
+</script>
+</body>
+</html>
+`;
+}
+
+// src/progress.ts
+var BAR_WIDTH = 20;
+var THROTTLE_MS = 50;
+function formatMB(bytes) {
+  return (bytes / (1024 * 1024)).toFixed(1);
+}
+function renderBar(ratio) {
+  const clamped = Math.max(0, Math.min(1, ratio));
+  const filled = Math.round(clamped * BAR_WIDTH);
+  return "\u2588".repeat(filled) + "\u2591".repeat(BAR_WIDTH - filled);
+}
+function createProgress(totalBytes, fileCount) {
+  if (!process.stderr.isTTY) {
+    return { tick: () => {
+    }, done: () => {
+    } };
+  }
+  let lastDraw = 0;
+  function draw(bytesDone, fileIdx) {
+    const ratio = totalBytes === 0 ? 1 : bytesDone / totalBytes;
+    const pct = Math.round(ratio * 100);
+    const line = `\r[${renderBar(ratio)}] ${pct}%  ${fileIdx} / ${fileCount} files  \xB7  ${formatMB(bytesDone)} / ${formatMB(totalBytes)} MB`;
+    process.stderr.write(line);
+    lastDraw = Date.now();
+  }
+  return {
+    tick(bytesDone, fileIdx) {
+      const now = Date.now();
+      if (lastDraw !== 0 && now - lastDraw < THROTTLE_MS) return;
+      draw(bytesDone, fileIdx);
+    },
+    done() {
+      process.stderr.write("\r\x1B[K\n");
+    }
+  };
+}
+
+// src/pipeline.ts
+var TOP_N = 100;
+function buildStamp(now = /* @__PURE__ */ new Date()) {
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(
+    now.getDate()
+  )}-${pad(now.getHours())}${pad(now.getMinutes())}`;
+}
+function outputFilename(stamp) {
+  return `ok-claude-result-${stamp}.html`;
+}
+var GENERIC_OS_USERNAMES = /^(user|administrator|admin|default(\s|-)?user|root|nobody)$/i;
+function slugName(raw) {
+  return raw.toLowerCase().normalize("NFKD").replace(/[̀-ͯ]/g, "").replace(/[^a-z0-9]/g, "");
+}
+function tryGitName() {
+  try {
+    const out = execSync("git config --get user.name", {
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 1e3
+    }).toString().trim();
+    if (!out) return null;
+    const slug = slugName(out);
+    return slug.length > 0 ? slug : null;
+  } catch {
+    return null;
+  }
+}
+function tryOsName() {
+  try {
+    const name = userInfo().username;
+    if (!name || GENERIC_OS_USERNAMES.test(name)) return null;
+    const slug = slugName(name);
+    return slug.length > 0 ? slug : null;
+  } catch {
+    return null;
+  }
+}
+function getUsername() {
+  return tryGitName() ?? tryOsName() ?? "you";
+}
+function outputDir() {
+  const downloads = join2(homedir2(), "Downloads");
+  try {
+    if (statSync(downloads).isDirectory()) return downloads;
+  } catch {
+  }
+  return process.cwd();
+}
+async function run() {
+  const files = await discoverLogs();
+  if (files.length === 0) {
+    return {
+      outPath: null,
+      reason: `No Claude Code logs found at ${logsRoot()}`
+    };
+  }
+  const totalBytes = files.reduce((s, f) => s + f.size, 0);
+  const progress = createProgress(totalBytes, files.length);
+  const userMap = /* @__PURE__ */ new Map();
+  const claudeMap = /* @__PURE__ */ new Map();
+  const userOpeners = /* @__PURE__ */ new Map();
+  const claudeOpeners = /* @__PURE__ */ new Map();
+  let messages = 0;
+  let tokensIn = 0;
+  let tokensOut = 0;
+  let minTs;
+  let maxTs;
+  for await (const e of streamEvents(files, progress.tick)) {
+    const denoised = denoiseMarkdown(e.text);
+    const op = firstOpener(denoised);
+    if (op) {
+      foldOpener(e.role === "user" ? userOpeners : claudeOpeners, op);
+    }
+    const map = e.role === "user" ? userMap : claudeMap;
+    for (const tok of tokenize(denoised)) {
+      map.set(tok, (map.get(tok) ?? 0) + 1);
+    }
+    messages++;
+    if (typeof e.tokensIn === "number") tokensIn += e.tokensIn;
+    if (typeof e.tokensOut === "number") tokensOut += e.tokensOut;
+    if (e.timestamp) {
+      if (minTs === void 0 || e.timestamp < minTs) minTs = e.timestamp;
+      if (maxTs === void 0 || e.timestamp > maxTs) maxTs = e.timestamp;
+    }
+  }
+  progress.done();
+  const topUser = topNOpeners(userOpeners, TOP_N).map(
+    (e) => [e.display, e.count]
+  );
+  const topClaude = topNOpeners(
+    claudeOpeners,
+    TOP_N
+  ).map((e) => [e.display, e.count]);
+  const stamp = buildStamp();
+  const html = renderHtml({
+    topUser,
+    topClaude,
+    meta: {
+      sessions: files.length,
+      messages,
+      tokensIn,
+      tokensOut,
+      dateRange: minTs !== void 0 && maxTs !== void 0 ? [minTs, maxTs] : null,
+      timestamp: stamp,
+      username: getUsername()
+    }
+  });
+  const outPath = resolve(outputDir(), outputFilename(stamp));
+  await writeFile(outPath, html, "utf8");
+  return { outPath };
+}
+
+// src/cli.ts
+async function main() {
+  const result = await run();
+  if (result.outPath) {
+    process.stdout.write(`Wrote ${result.outPath}
+`);
+    await open(result.outPath);
+    return;
+  }
+  process.stderr.write(result.reason + "\n");
+}
+main().catch((err) => {
+  process.stderr.write(`ok-claude: ${err.message}
+`);
+  process.exit(1);
+});