vibewrapped 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 eliseomdq
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,67 @@
-# Temporary Holding Version
+# vibewrapped
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**Spotify Wrapped for your AI coding agent.** One command turns your local Claude Code history into a card you'll actually want to post.
+
+```bash
+npx vibewrapped
+```
+
+![Vibe Coding Wrapped card](https://raw.githubusercontent.com/eliseomdq/vibewrapped/main/docs/card.png)
+
+*Sample card. Yours is built from your own sessions.*
+
+## What's on your card
+
+- **Tokens** you pushed through Claude Code (cache included, deduplicated per message)
+- **Your coding persona**: The 3AM Shipper, The Orchestrator, The Backseat Driver, The Terminal Goblin…
+- Sessions, hours with your agent, longest day streak, prompts, tool calls, peak hour
+- **Claude's catchphrase**: the verbal tic it repeated most to you ("Let me…", "Perfect!", "Good catch"…), and if it still says it, the legendary **"You're absolutely right!"** count
+
+## ⚠️ Claude Code is deleting your history
+
+By default Claude Code deletes session transcripts older than **30 days** ([`cleanupPeriodDays`](https://code.claude.com/docs/en/settings-reference#cleanupperioddays)). If you want your December wrapped to cover more than November, run this today:
+
+```bash
+npx vibewrapped --keep
+```
+
+It sets `cleanupPeriodDays` to 3650 in your `~/.claude/settings.json` and leaves every other setting alone.
+
+## Options
+
+```
+--year <yyyy>    Only count one calendar year (default: all history)
+--dir <path>     Claude config dir (default: $CLAUDE_CONFIG_DIR or ~/.claude); repeatable
+--out <file>     Where to save the card (default: ./vibewrapped.png)
+--json           Print the raw stats as JSON
+--share          Open a pre-filled post on X (you attach the image)
+--keep           Stop Claude Code from deleting history after 30 days
+--no-open        Do not open the card when done
+```
+
+## As a Claude Code plugin
+
+```
+/plugin marketplace add eliseomdq/vibewrapped
+/plugin install vibewrapped@vibewrapped
+```
+
+Then ask Claude for your wrapped, or run `/vibewrapped:wrapped`.
+
+## Privacy
+
+Everything runs on your machine. vibewrapped reads the JSONL transcripts in `~/.claude/projects`, renders the PNG locally with bundled fonts and makes no network requests. The card only shows aggregate numbers: no project names, paths, branches or prompts.
+
+## How the numbers are counted
+
+- Claude Code writes one line per content block, so usage is counted once per message id and tool calls once per tool_use id.
+- Prompts are your own messages: tool results, system notifications and interrupts are excluded.
+- Active time adds up the gaps between events in a session, ignoring gaps over 30 minutes.
+- Subagent runs count toward tokens and tool calls, not toward sessions or prompts.
+- Days and hours use your machine's time zone.
+
+Codex, Cursor and Gemini CLI support is next. PRs welcome.
+
+## License
+
+MIT. Card fonts: [Geist](https://github.com/vercel/geist-font), SIL Open Font License.

package/assets/fonts/OFL.txt

@@ -0,0 +1,93 @@
+Copyright 2024 The Geist Project Authors (https://github.com/vercel/geist-font)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+https://openfontlicense.org
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

package/bin/vibewrapped.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+import { mkdir, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { parseArgs } from 'node:util';
+import { defaultClaudeDirs, findSessionFiles, readRecords } from '../src/sessions.js';
+import { computeStats } from '../src/stats.js';
+import { renderCardSvg, highlight } from '../src/card.js';
+import { svgToPng } from '../src/render.js';
+import { pickPersona } from '../src/persona.js';
+import { compact, dateRange, hourLabel } from '../src/format.js';
+import { DEFAULT_DAYS, keepHistory, retentionDays } from '../src/retention.js';
+
+const HELP = `vibewrapped — Spotify Wrapped for your AI coding agent
+
+Usage: npx vibewrapped [options]
+
+  --year <yyyy>    Only count one calendar year (default: all history)
+  --dir <path>     Claude config dir (default: $CLAUDE_CONFIG_DIR or ~/.claude); repeatable
+  --out <file>     Where to save the card (default: ./vibewrapped.png)
+  --json           Print the raw stats as JSON instead of the card
+  --share          Open a pre-filled post on X (you attach the image)
+  --keep           Stop Claude Code from deleting history after 30 days
+                   (sets cleanupPeriodDays to 3650 in settings.json)
+  --no-open        Do not open the card when done
+  -h, --help       Show this help
+
+Everything runs locally. Nothing is uploaded.`;
+
+const { values } = parseArgs({
+  options: {
+    year: { type: 'string' },
+    dir: { type: 'string', multiple: true },
+    out: { type: 'string', default: 'vibewrapped.png' },
+    json: { type: 'boolean', default: false },
+    share: { type: 'boolean', default: false },
+    keep: { type: 'boolean', default: false },
+    'no-open': { type: 'boolean', default: false },
+    help: { type: 'boolean', short: 'h', default: false },
+  },
+});
+
+if (values.help) {
+  process.stdout.write(`${HELP}\n`);
+  process.exit(0);
+}
+
+if (values.year && !/^\d{4}$/.test(values.year)) {
+  process.stderr.write(`--year must look like 2026, got "${values.year}"\n`);
+  process.exit(1);
+}
+
+const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+const dirs = values.dir ?? defaultClaudeDirs(process.env, homedir());
+
+const files = (await Promise.all(dirs.map(findSessionFiles))).flat();
+
+if (files.length === 0) {
+  process.stderr.write(`No Claude Code sessions found in ${dirs.join(', ')}.\nPoint me at your config dir with --dir <path>.\n`);
+  process.exit(1);
+}
+
+// Local midnight, matching the time zone used for days and hours.
+const since = values.year ? new Date(Number(values.year), 0, 1) : undefined;
+const until = values.year ? new Date(Number(values.year) + 1, 0, 1) : undefined;
+
+process.stderr.write(`Reading ${files.length} session files…\n`);
+let unreadable = 0;
+const stats = await computeStats(readRecords(files, () => unreadable++), { timeZone, since, until });
+if (unreadable) process.stderr.write(`Skipped ${unreadable} session files that could not be read.\n`);
+
+async function keep() {
+  for (const dir of dirs) {
+    try {
+      const { before, after } = await keepHistory(dir);
+      process.stderr.write(`History retention in ${dir}: ${before ?? `${DEFAULT_DAYS} (default)`} → ${after} days\n`);
+    } catch (error) {
+      process.stderr.write(`Could not update ${dir}: ${error.message}\n`);
+      process.exitCode = 1;
+    }
+  }
+}
+
+if (values.json) {
+  process.stdout.write(`${JSON.stringify(stats, null, 2)}\n`);
+  if (values.keep) await keep();
+  process.exit();
+}
+
+if (stats.prompts === 0) {
+  process.stderr.write('No prompts found in that range. Try without --year.\n');
+  process.exit(1);
+}
+
+const out = path.resolve(values.out);
+await mkdir(path.dirname(out), { recursive: true });
+await writeFile(out, svgToPng(renderCardSvg(stats, { timeZone })));
+
+const persona = pickPersona(stats);
+const hi = highlight(stats);
+const cost = stats.costUSD === null ? '' : `\n  API-equivalent cost   $${compact(stats.costUSD)}`;
+process.stdout.write(`
+  VIBE CODING WRAPPED   ${dateRange(stats.range, timeZone)}
+
+  ${compact(stats.tokens.total)} tokens through Claude Code
+  You are ${persona.name}. ${persona.line}
+
+  sessions              ${stats.sessions}
+  hours with your agent ${Math.round(stats.activeMinutes / 60)}
+  day streak            ${stats.longestStreak}
+  prompts               ${stats.prompts}
+  tool calls            ${stats.toolCalls}
+  peak hour             ${hourLabel(stats.peakHour)}
+  favorite tool         ${stats.topTools[0]?.name ?? '—'}
+  favorite model        ${stats.topModels[0]?.name ?? '—'}${cost}
+
+  ${hi.quote} ×${hi.count}
+
+  Card saved to ${out}
+`);
+
+if (values.keep) {
+  await keep();
+} else {
+  const retention = Math.min(...(await Promise.all(dirs.map(retentionDays))));
+  if (retention <= DEFAULT_DAYS) {
+    process.stdout.write(`
+  Heads up: Claude Code deletes sessions older than ${retention} days, so this card can't go further back.
+  Run "npx vibewrapped --keep" now and your December wrapped will cover the whole stretch.
+`);
+  }
+}
+
+function open(target) {
+  const [cmd, args] =
+    process.platform === 'darwin' ? ['open', [target]]
+    : process.platform === 'win32' ? ['cmd', ['/c', 'start', '""', target]]
+    : ['xdg-open', [target]];
+  // Opening is a convenience: on a headless box the card is still saved and its path printed.
+  spawn(cmd, args, { detached: true, stdio: 'ignore' }).on('error', () => {}).unref();
+}
+
+if (!values['no-open']) open(out);
+
+if (values.share) {
+  const text = `My vibe coding wrapped: ${compact(stats.tokens.total)} tokens, ${stats.sessions} sessions, and I'm "${persona.name}".\n\n${hi.quote} ×${hi.count} 💀\n\nGet yours: npx vibewrapped`;
+  open(`https://x.com/intent/tweet?text=${encodeURIComponent(text)}&url=${encodeURIComponent('https://github.com/eliseomdq/vibewrapped')}`);
+  process.stdout.write('  Opened X in your browser. Attach the card and post.\n');
+}

package/package.json

@@ -1,6 +1,40 @@
 {
   "name": "vibewrapped",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Spotify Wrapped for your AI coding agent. One command turns your local Claude Code history into a shareable card. 100% local.",
+  "type": "module",
+  "bin": {
+    "vibewrapped": "bin/vibewrapped.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "assets"
+  ],
+  "scripts": {
+    "test": "node --test",
+    "test:coverage": "node --test --experimental-test-coverage"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "claude-code",
+    "wrapped",
+    "ai",
+    "agent",
+    "vibe-coding",
+    "claude",
+    "stats",
+    "cli"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@resvg/resvg-js": "^2.6.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eliseomdq/vibewrapped.git"
+  },
+  "homepage": "https://github.com/eliseomdq/vibewrapped"
+}

package/src/card.js

@@ -0,0 +1,114 @@
+import { compact, dateRange, escapeXml, hourLabel } from './format.js';
+import { pickPersona } from './persona.js';
+
+export const CARD_WIDTH = 1200;
+export const CARD_HEIGHT = 675;
+const REPO = 'github.com/eliseomdq/vibewrapped';
+
+const C = {
+  bg: '#0A0B14',
+  text: '#F5F3FF',
+  muted: '#9C99B8',
+  accent: '#FF7A59',
+  violet: '#8B6CFF',
+};
+
+/**
+ * The meme line at the bottom of the card: the most screenshot-worthy stat available.
+ * @param {import('./stats.js').Stats} stats
+ */
+export function highlight(stats) {
+  if (stats.absolutelyRight >= 10) {
+    return { quote: '“You’re absolutely right!”', count: stats.absolutelyRight, caption: 'times Claude said it to you' };
+  }
+  const [top] = stats.catchphrases;
+  if (top) {
+    return { quote: `“${top.name}”`, count: top.count, caption: 'Claude’s catchphrase: times it said it to you' };
+  }
+  if (stats.interrupts > 0) {
+    return { quote: 'Esc pressed mid-answer', count: stats.interrupts, caption: 'times you stopped Claude to correct it' };
+  }
+  if (stats.politePrompts > 0) {
+    return { quote: 'please & thank you', count: stats.politePrompts, caption: 'prompts where you were polite to a robot' };
+  }
+  return { quote: 'prompts', count: stats.prompts, caption: 'prompts sent' };
+}
+
+/** Shrinks a font size so a line of text fits the given width (Geist averages ~0.56em per glyph). */
+function fit(text, maxSize, width) {
+  return Math.min(maxSize, Math.floor(width / (text.length * 0.56)));
+}
+
+function stat(x, y, value, label) {
+  return `
+    <text x="${x}" y="${y}" font-family="Geist Mono" font-weight="700" font-size="44" fill="${C.text}">${escapeXml(value)}</text>
+    <text x="${x}" y="${y + 30}" font-family="Geist" font-size="17" fill="${C.muted}">${escapeXml(label)}</text>`;
+}
+
+/**
+ * Renders the shareable card. Only aggregate numbers appear on it: no paths, projects or branches.
+ * @param {import('./stats.js').Stats} stats
+ * @param {{ timeZone: string }} options
+ * @returns {string}
+ */
+export function renderCardSvg(stats, { timeZone }) {
+  const persona = pickPersona(stats);
+  const hi = highlight(stats);
+  const range = stats.range ? dateRange(stats.range, timeZone) : '';
+  const hours = Math.round(stats.activeMinutes / 60);
+  const cells = [
+    [compact(stats.sessions), 'sessions'],
+    [compact(hours), 'hours with your agent'],
+    [`${stats.longestStreak}`, 'day streak'],
+    [compact(stats.prompts), 'prompts'],
+    [compact(stats.toolCalls), 'tool calls'],
+    [hourLabel(stats.peakHour), 'peak hour'],
+  ];
+  const grid = cells
+    .map(([value, label], i) => stat(712 + (i % 2) * 230, 190 + Math.floor(i / 2) * 100, value, label))
+    .join('');
+  const tokens = compact(stats.tokens.total);
+  const personaSize = fit(persona.name, 50, 580);
+  const quoteSize = fit(hi.quote, 30, 700);
+
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${CARD_WIDTH}" height="${CARD_HEIGHT}" viewBox="0 0 ${CARD_WIDTH} ${CARD_HEIGHT}">
+  <defs>
+    <radialGradient id="glowA" cx="0.12" cy="0.1" r="0.7">
+      <stop offset="0" stop-color="${C.violet}" stop-opacity="0.45"/>
+      <stop offset="1" stop-color="${C.violet}" stop-opacity="0"/>
+    </radialGradient>
+    <radialGradient id="glowB" cx="0.95" cy="1" r="0.65">
+      <stop offset="0" stop-color="${C.accent}" stop-opacity="0.35"/>
+      <stop offset="1" stop-color="${C.accent}" stop-opacity="0"/>
+    </radialGradient>
+    <linearGradient id="hero" x1="0" y1="0" x2="1" y2="0">
+      <stop offset="0" stop-color="#FFB199"/>
+      <stop offset="0.55" stop-color="${C.accent}"/>
+      <stop offset="1" stop-color="${C.violet}"/>
+    </linearGradient>
+  </defs>
+  <rect width="${CARD_WIDTH}" height="${CARD_HEIGHT}" fill="${C.bg}"/>
+  <rect width="${CARD_WIDTH}" height="${CARD_HEIGHT}" fill="url(#glowA)"/>
+  <rect width="${CARD_WIDTH}" height="${CARD_HEIGHT}" fill="url(#glowB)"/>
+
+  <text x="64" y="84" font-family="Geist Mono" font-weight="700" font-size="17" letter-spacing="4" fill="${C.accent}">VIBE CODING WRAPPED</text>
+  <text x="1136" y="84" text-anchor="end" font-family="Geist Mono" font-size="17" fill="${C.muted}">${escapeXml(range)}</text>
+
+  <text x="58" y="250" font-family="Geist" font-weight="900" font-size="150" letter-spacing="-3" fill="url(#hero)">${escapeXml(tokens)}</text>
+  <text x="64" y="292" font-family="Geist" font-size="24" fill="${C.muted}">tokens through Claude Code</text>
+
+  <text x="64" y="370" font-family="Geist" font-size="20" fill="${C.muted}">You are</text>
+  <text x="64" y="${370 + personaSize + 6}" font-family="Geist" font-weight="700" font-size="${personaSize}" fill="${C.text}">${escapeXml(persona.name)}</text>
+  <text x="64" y="${370 + personaSize + 44}" font-family="Geist" font-size="20" fill="${C.muted}">${escapeXml(persona.line)}</text>
+
+  ${grid}
+
+  <rect x="64" y="490" width="1072" height="104" rx="18" fill="#FFFFFF" fill-opacity="0.05" stroke="#FFFFFF" stroke-opacity="0.12"/>
+  <text x="96" y="535" font-family="Geist" font-weight="700" font-size="${quoteSize}" fill="${C.text}">${escapeXml(hi.quote)}</text>
+  <text x="96" y="570" font-family="Geist" font-size="18" fill="${C.muted}">${escapeXml(hi.caption)}</text>
+  <text x="1104" y="562" text-anchor="end" font-family="Geist" font-weight="900" font-size="64" fill="${C.accent}">×${escapeXml(compact(hi.count))}</text>
+
+  <text x="64" y="640" font-family="Geist Mono" font-size="18" fill="${C.text}">$ npx vibewrapped</text>
+  <text x="1136" y="640" text-anchor="end" font-family="Geist Mono" font-size="16" fill="${C.muted}">${REPO}</text>
+</svg>`;
+}

package/src/format.js

@@ -0,0 +1,34 @@
+const UNITS = [
+  [1e9, 'B'],
+  [1e6, 'M'],
+  [1e3, 'K'],
+];
+
+/** @param {number} n @returns {string} */
+export function compact(n) {
+  for (const [size, unit] of UNITS) {
+    if (n >= size) return `${Number((n / size).toFixed(1))}${unit}`;
+  }
+  return String(Math.round(n));
+}
+
+/** @param {number | null} hour @returns {string} */
+export function hourLabel(hour) {
+  if (hour === null) return '—';
+  const h = hour % 12 === 0 ? 12 : hour % 12;
+  return `${h} ${hour < 12 ? 'AM' : 'PM'}`;
+}
+
+/** @param {{ first: string, last: string }} range @param {string} timeZone @returns {string} */
+export function dateRange({ first, last }, timeZone) {
+  const fmt = (iso, withYear) =>
+    new Intl.DateTimeFormat('en-US', { timeZone, month: 'short', day: 'numeric', ...(withYear && { year: 'numeric' }) }).format(new Date(iso));
+  const year = (iso) => new Intl.DateTimeFormat('en-US', { timeZone, year: 'numeric' }).format(new Date(iso));
+  const sameYear = year(first) === year(last);
+  return `${fmt(first, !sameYear)} – ${fmt(last, true)}`;
+}
+
+/** @param {string} s @returns {string} */
+export function escapeXml(s) {
+  return s.replace(/[<>&"']/g, (c) => ({ '<': '&lt;', '>': '&gt;', '&': '&amp;', '"': '&quot;', "'": '&apos;' })[c]);
+}

package/src/persona.js

@@ -0,0 +1,38 @@
+const PERSONAS = {
+  shipper3am: { name: 'The 3AM Shipper', line: 'Your best ideas show up after midnight. So do your bugs.' },
+  orchestrator: { name: 'The Orchestrator', line: 'Why do one thing when ten agents can do it?' },
+  backseat: { name: 'The Backseat Driver', line: 'You hit Esc like it owes you money.' },
+  goblin: { name: 'The Terminal Goblin', line: "If it can't be piped, it doesn't exist." },
+  refactorer: { name: 'The Relentless Refactorer', line: 'No line of code is ever finished.' },
+  archaeologist: { name: 'The Code Archaeologist', line: 'You dig through the codebase before you touch it.' },
+  nightOwl: { name: 'The Night Owl', line: 'Daylight is for meetings. Night is for shipping.' },
+  earlyShipper: { name: 'The Early Shipper', line: 'Merged before the coffee got cold.' },
+  architect: { name: 'The Vibe Architect', line: 'You describe it. It ships.' },
+};
+
+const TOOL_PERSONAS = {
+  Bash: PERSONAS.goblin,
+  Edit: PERSONAS.refactorer,
+  MultiEdit: PERSONAS.refactorer,
+  Write: PERSONAS.refactorer,
+  Read: PERSONAS.archaeologist,
+  Grep: PERSONAS.archaeologist,
+  Glob: PERSONAS.archaeologist,
+};
+
+/**
+ * Picks the archetype shown on the card, from the most to the least distinctive trait.
+ * @param {{ peakHour: number | null, sessions: number, subagentRuns: number, prompts: number,
+ *   interrupts: number, topTools: { name: string }[] }} stats
+ * @returns {{ name: string, line: string }}
+ */
+export function pickPersona({ peakHour, sessions, subagentRuns, prompts, interrupts, topTools }) {
+  if (peakHour !== null && peakHour < 5) return PERSONAS.shipper3am;
+  if (subagentRuns >= 5 && subagentRuns >= sessions * 0.5) return PERSONAS.orchestrator;
+  if (interrupts >= 5 && interrupts >= prompts * 0.1) return PERSONAS.backseat;
+  const byTool = topTools[0] && TOOL_PERSONAS[topTools[0].name];
+  if (byTool) return byTool;
+  if (peakHour !== null && peakHour >= 20) return PERSONAS.nightOwl;
+  if (peakHour !== null && peakHour < 9) return PERSONAS.earlyShipper;
+  return PERSONAS.architect;
+}

package/src/render.js

@@ -0,0 +1,22 @@
+import { Resvg } from '@resvg/resvg-js';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import { CARD_WIDTH } from './card.js';
+
+const FONTS = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'assets', 'fonts');
+const FONT_FILES = ['Geist-Regular', 'Geist-Bold', 'Geist-Black', 'GeistMono-Regular', 'GeistMono-Bold'].map((f) =>
+  path.join(FONTS, `${f}.ttf`),
+);
+
+/**
+ * Rasterizes the card at 2x with bundled fonts, so it looks the same on every machine.
+ * @param {string} svg
+ * @returns {Buffer}
+ */
+export function svgToPng(svg) {
+  const resvg = new Resvg(svg, {
+    font: { fontFiles: FONT_FILES, loadSystemFonts: false, defaultFontFamily: 'Geist' },
+    fitTo: { mode: 'width', value: CARD_WIDTH * 2 },
+  });
+  return resvg.render().asPng();
+}

package/src/retention.js

@@ -0,0 +1,57 @@
+import { randomUUID } from 'node:crypto';
+import { chmod, readFile, rename, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+
+// Claude Code deletes transcripts older than cleanupPeriodDays, 30 by default.
+export const DEFAULT_DAYS = 30;
+export const KEEP_DAYS = 3650;
+
+/** @param {string} claudeDir @returns {Promise<Record<string, unknown> | null>} */
+async function readSettings(claudeDir) {
+  const file = path.join(claudeDir, 'settings.json');
+  let raw;
+  try {
+    raw = await readFile(file, 'utf8');
+  } catch (error) {
+    if (error.code === 'ENOENT') return null;
+    throw error;
+  }
+  let settings;
+  try {
+    settings = JSON.parse(raw);
+  } catch {
+    throw new Error(`${file} is not valid JSON; fix it before running --keep`);
+  }
+  if (typeof settings !== 'object' || settings === null || Array.isArray(settings)) {
+    throw new Error(`${file} is not a JSON object; fix it before running --keep`);
+  }
+  return settings;
+}
+
+/** @param {string} claudeDir @returns {Promise<number>} */
+export async function retentionDays(claudeDir) {
+  const settings = await readSettings(claudeDir).catch(() => null);
+  return typeof settings?.cleanupPeriodDays === 'number' ? settings.cleanupPeriodDays : DEFAULT_DAYS;
+}
+
+/**
+ * Raises cleanupPeriodDays in the user's settings.json so Claude Code stops deleting history.
+ * Writes to a temp file and renames it, so the settings file is never left half-written.
+ * @param {string} claudeDir
+ * @returns {Promise<{ before: number | null, after: number }>}
+ */
+export async function keepHistory(claudeDir) {
+  const isDir = await stat(claudeDir).then((s) => s.isDirectory(), () => false);
+  if (!isDir) throw new Error(`${claudeDir} does not exist`);
+  const settings = (await readSettings(claudeDir)) ?? {};
+  const before = typeof settings.cleanupPeriodDays === 'number' ? settings.cleanupPeriodDays : null;
+  if (before !== null && before >= KEEP_DAYS) return { before, after: before };
+  const file = path.join(claudeDir, 'settings.json');
+  // settings.json can hold API keys in its env block: keep its mode, and default new files to 0600.
+  const mode = await stat(file).then((s) => s.mode & 0o777, () => 0o600);
+  const tmp = `${file}.vibewrapped-${randomUUID()}.tmp`;
+  await writeFile(tmp, `${JSON.stringify({ ...settings, cleanupPeriodDays: KEEP_DAYS }, null, 2)}\n`, { mode, flag: 'wx' });
+  await chmod(tmp, mode);
+  await rename(tmp, file);
+  return { before, after: KEEP_DAYS };
+}

package/src/sessions.js

@@ -0,0 +1,68 @@
+import { createReadStream } from 'node:fs';
+import { readdir } from 'node:fs/promises';
+import path from 'node:path';
+import readline from 'node:readline';
+
+/**
+ * @typedef {{ path: string, isSubagent: boolean }} SessionFile
+ */
+
+/**
+ * @param {Record<string, string | undefined>} env
+ * @param {string} home
+ * @returns {string[]}
+ */
+export function defaultClaudeDirs(env, home) {
+  return env.CLAUDE_CONFIG_DIR ? [env.CLAUDE_CONFIG_DIR] : [path.join(home, '.claude')];
+}
+
+/**
+ * Lists every session transcript under <claudeDir>/projects, including subagent runs
+ * stored in <session>/subagents/.
+ * @param {string} claudeDir
+ * @returns {Promise<SessionFile[]>}
+ */
+export async function findSessionFiles(claudeDir) {
+  const projects = path.join(claudeDir, 'projects');
+  let entries;
+  try {
+    entries = await readdir(projects, { recursive: true, withFileTypes: true });
+  } catch (error) {
+    if (error.code === 'ENOENT') return [];
+    throw error;
+  }
+  return entries
+    .filter((e) => e.isFile() && e.name.endsWith('.jsonl'))
+    .map((e) => {
+      const dir = e.parentPath ?? e.path;
+      return { path: path.join(dir, e.name), isSubagent: path.basename(dir) === 'subagents' };
+    });
+}
+
+/**
+ * Streams parsed JSONL records. Lines that are not valid JSON (partial writes) are skipped,
+ * and so are files that vanish or can't be read mid-run (Claude Code's own cleanup can delete them).
+ * @param {SessionFile[]} files
+ * @param {(file: string, error: Error) => void} onUnreadable
+ * @returns {AsyncGenerator<{ file: string, record: any, isSubagent: boolean }>}
+ */
+export async function* readRecords(files, onUnreadable = () => {}) {
+  for (const { path: file, isSubagent } of files) {
+    const parsed = [];
+    try {
+      const lines = readline.createInterface({ input: createReadStream(file), crlfDelay: Infinity });
+      for await (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          parsed.push(JSON.parse(line));
+        } catch {
+          continue;
+        }
+      }
+    } catch (error) {
+      onUnreadable(file, error);
+      continue;
+    }
+    for (const record of parsed) yield { file, record, isSubagent };
+  }
+}

package/src/stats.js

@@ -0,0 +1,229 @@
+const BREAK_MS = 30 * 60 * 1000;
+const ABSOLUTELY_RIGHT = /you('| a)?re absolutely right|ten[eé]s toda la raz[oó]n|tienes toda la raz[oó]n/i;
+// Verbal tics counted in Claude's replies; the most frequent one becomes the card's catchphrase.
+const CATCHPHRASES = [
+  ['Let me…', /\blet me\b/i],
+  ['You’re right', /\byou('| a)re (absolutely )?right\b/i],
+  ['Perfect!', /^perfect[!.]/im],
+  ['Great question', /\bgreat question\b/i],
+  ['Good catch', /\bgood catch\b/i],
+  ['My mistake', /\bmy (mistake|bad)\b|\bI apologi[sz]e\b/i],
+  ['Done.', /^done[!.]/im],
+  ['Déjame…', /\bd[eé]jame\b/i],
+  ['Tenés razón', /\bten[eé]s (toda la )?raz[oó]n|\btienes (toda la )?raz[oó]n/i],
+  ['Me equivoqué', /\bme equivoqu[eé]/i],
+  ['Listo.', /^listo[!.]/im],
+];
+const POLITE = /\b(please|pls|plz|thanks|thank you|ty)\b|por favor|gracias/i;
+const INTERRUPT = /^\[Request interrupted by user/;
+// Tags Claude Code wraps around messages it injects as "user" turns.
+const SYSTEM_TAG = /^<(task-notification|fork-boilerplate|local-command-caveat|local-command-stdout|local-command-stderr|command-name|command-message|command-args|bash-input|bash-stdout|bash-stderr|system-reminder|artifact-content-authored-by-others)\b/;
+
+/**
+ * @typedef {{ file: string, record: any, isSubagent: boolean }} SourceRecord
+ * @typedef {{ name: string, count: number }} Ranked
+ * @typedef {{
+ *   range: { first: string, last: string } | null,
+ *   sessions: number, subagentRuns: number, prompts: number, interrupts: number,
+ *   politePrompts: number, messages: number, toolCalls: number, absolutelyRight: number,
+ *   tokens: { input: number, output: number, cacheRead: number, cacheWrite: number, total: number },
+ *   costUSD: number | null, topTools: Ranked[], topModels: Ranked[], catchphrases: Ranked[],
+ *   activeDays: number, longestStreak: number, peakHour: number | null,
+ *   hours: number[], activeMinutes: number, longestSessionMinutes: number,
+ * }} Stats
+ */
+
+/** @param {unknown} content @returns {string | null} */
+function promptText(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content) || content.some((b) => b?.type === 'tool_result')) return null;
+  const text = content.find((b) => b?.type === 'text' && typeof b.text === 'string');
+  return text ? text.text : null;
+}
+
+/** @param {unknown} n */
+function num(n) {
+  return typeof n === 'number' && Number.isFinite(n) ? n : 0;
+}
+
+/** @param {Map<string, number>} counts @param {number} limit @returns {Ranked[]} */
+function rank(counts, limit) {
+  return [...counts.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, limit)
+    .map(([name, count]) => ({ name, count }));
+}
+
+/** @param {Date} date @param {string} timeZone */
+function localParts(date, timeZone) {
+  const parts = new Intl.DateTimeFormat('en-CA', {
+    timeZone, year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', hourCycle: 'h23',
+  }).formatToParts(date);
+  const get = (type) => parts.find((p) => p.type === type).value;
+  return { day: `${get('year')}-${get('month')}-${get('day')}`, hour: Number(get('hour')) };
+}
+
+/** @param {string[]} days sorted YYYY-MM-DD */
+function longestStreak(days) {
+  let best = 0;
+  let run = 0;
+  let prev = null;
+  for (const day of days) {
+    const t = Date.parse(`${day}T00:00:00Z`);
+    run = prev !== null && t - prev === 86400000 ? run + 1 : 1;
+    best = Math.max(best, run);
+    prev = t;
+  }
+  return best;
+}
+
+/** @param {number[]} times sorted epoch ms */
+function activeMs(times) {
+  let total = 0;
+  for (let i = 1; i < times.length; i++) {
+    const gap = times[i] - times[i - 1];
+    if (gap <= BREAK_MS) total += gap;
+  }
+  return total;
+}
+
+/**
+ * Aggregates Claude Code session records into wrapped stats.
+ * Assistant messages are split across several lines sharing one message id,
+ * so usage is counted once per id and tool calls once per tool_use id.
+ * @param {AsyncIterable<SourceRecord>} records
+ * @param {{ timeZone: string, since?: Date, until?: Date }} options
+ * @returns {Promise<Stats>}
+ */
+export async function computeStats(records, { timeZone, since, until }) {
+  const usageById = new Map();
+  const promptIds = new Set();
+  const toolIds = new Set();
+  const textBlocks = new Set();
+  const tools = new Map();
+  const models = new Map();
+  const costByFile = new Map();
+  const timesByFile = new Map();
+  const sessionFiles = new Set();
+  const subagentFiles = new Set();
+  const days = new Set();
+  const hours = Array(24).fill(0);
+  let prompts = 0;
+  let interrupts = 0;
+  let politePrompts = 0;
+  let absolutelyRight = 0;
+  const phrases = new Map();
+  let first = null;
+  let last = null;
+
+  for await (const { file, record, isSubagent } of records) {
+    if (record?.type === 'cost-state') {
+      if (typeof record.totalCostUSD === 'number') costByFile.set(file, record.totalCostUSD);
+      continue;
+    }
+    if (record?.type !== 'user' && record?.type !== 'assistant') continue;
+    if (typeof record.timestamp !== 'string' && record.timestamp !== undefined) continue;
+
+    const time = record.timestamp ? new Date(record.timestamp) : null;
+    if (time && Number.isNaN(time.getTime())) continue;
+    if ((since || until) && !time) continue;
+    if (time && ((since && time < since) || (until && time >= until))) continue;
+
+    if (time) {
+      if (!first || time < first) first = time;
+      if (!last || time > last) last = time;
+      const list = timesByFile.get(file) ?? [];
+      list.push(time.getTime());
+      timesByFile.set(file, list);
+    }
+
+    if (record.type === 'user') {
+      if (isSubagent || record.isSidechain || record.isMeta || record.isCompactSummary) continue;
+      const text = promptText(record.message?.content);
+      if (text === null || SYSTEM_TAG.test(text)) continue;
+      if (record.uuid) {
+        if (promptIds.has(record.uuid)) continue;
+        promptIds.add(record.uuid);
+      }
+      if (INTERRUPT.test(text)) {
+        interrupts++;
+        continue;
+      }
+      prompts++;
+      if (POLITE.test(text)) politePrompts++;
+      sessionFiles.add(file);
+      if (time) {
+        const { day, hour } = localParts(time, timeZone);
+        days.add(day);
+        hours[hour]++;
+      }
+      continue;
+    }
+
+    const message = typeof record.message === 'object' && record.message !== null ? record.message : {};
+    if (isSubagent) subagentFiles.add(file);
+    if (typeof message.id === 'string') {
+      // A message is written once per content block and output_tokens grows as it streams,
+      // so keep the largest value seen for each field.
+      const usage = message.usage ?? {};
+      const prev = usageById.get(message.id);
+      usageById.set(message.id, {
+        input: Math.max(prev?.input ?? 0, num(usage.input_tokens)),
+        output: Math.max(prev?.output ?? 0, num(usage.output_tokens)),
+        cacheRead: Math.max(prev?.cacheRead ?? 0, num(usage.cache_read_input_tokens)),
+        cacheWrite: Math.max(prev?.cacheWrite ?? 0, num(usage.cache_creation_input_tokens)),
+      });
+      if (!prev && typeof message.model === 'string' && !message.model.startsWith('<')) {
+        models.set(message.model, (models.get(message.model) ?? 0) + 1);
+      }
+    }
+    for (const block of Array.isArray(message.content) ? message.content : []) {
+      if (block?.type === 'tool_use' && block.id && !toolIds.has(block.id)) {
+        toolIds.add(block.id);
+        tools.set(block.name, (tools.get(block.name) ?? 0) + 1);
+      }
+      if (block?.type === 'text' && typeof block.text === 'string') {
+        const key = `${message.id}:${block.text}`;
+        if (textBlocks.has(key)) continue;
+        textBlocks.add(key);
+        if (ABSOLUTELY_RIGHT.test(block.text)) absolutelyRight++;
+        for (const [label, pattern] of CATCHPHRASES) {
+          if (pattern.test(block.text)) phrases.set(label, (phrases.get(label) ?? 0) + 1);
+        }
+      }
+    }
+  }
+
+  const sessionDurations = [...timesByFile.entries()]
+    .filter(([file]) => sessionFiles.has(file))
+    .map(([, times]) => activeMs(times.sort((a, b) => a - b)));
+  const peak = Math.max(...hours);
+  const tokens = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+  for (const usage of usageById.values()) {
+    for (const key of Object.keys(tokens)) tokens[key] += usage[key];
+  }
+
+  return {
+    range: first ? { first: first.toISOString(), last: last.toISOString() } : null,
+    sessions: sessionFiles.size,
+    subagentRuns: subagentFiles.size,
+    prompts,
+    interrupts,
+    politePrompts,
+    messages: usageById.size,
+    toolCalls: toolIds.size,
+    absolutelyRight,
+    tokens: { ...tokens, total: tokens.input + tokens.output + tokens.cacheRead + tokens.cacheWrite },
+    // cost-state is a cumulative, undated total per session, so it can't be split by date.
+    costUSD: costByFile.size && !since && !until ? [...costByFile.values()].reduce((a, b) => a + b, 0) : null,
+    topTools: rank(tools, 5),
+    topModels: rank(models, 3),
+    catchphrases: rank(phrases, 3),
+    activeDays: days.size,
+    longestStreak: longestStreak([...days].sort()),
+    peakHour: peak > 0 ? hours.indexOf(peak) : null,
+    hours,
+    activeMinutes: Math.round(sessionDurations.reduce((a, b) => a + b, 0) / 60000),
+    longestSessionMinutes: Math.round(Math.max(0, ...sessionDurations) / 60000),
+  };
+}