vibestreak 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kingsbridge Consultancy LLC
+
+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,42 @@
-# Temporary Holding Version
+# vibestreak
 
-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.
+Your AI coding streak, from your own machine: a heatmap of the days you coded
+with AI agents and the commits you shipped with them, ranked on consistency,
+not spend. Profiles and the leaderboard: https://vibestreak.kingsbridge-consultancy.com
+
+```bash
+npx vibestreak login --token PASTE_YOUR_TOKEN   # token from Settings → Machines
+npx vibestreak emails scan                      # add every address you commit as
+npx vibestreak sync
+npx vibestreak autosync on                      # background syncs + evening streak check
+```
+
+All commands: https://vibestreak.kingsbridge-consultancy.com/cli
+
+## What it reads
+
+| Tool | Where |
+| --- | --- |
+| Claude Code | `~/.claude/projects` |
+| Codex | `~/.codex/sessions`, `~/.codex/archived_sessions` |
+| Cursor | its editor database and AI code-tracking database |
+| GitHub Copilot | Copilot CLI's `~/.copilot/session-state`; Copilot Chat sessions in VS Code |
+| Gemini CLI | `~/.gemini/tmp/*/chats` |
+| Antigravity | `~/.gemini/antigravity/conversations` |
+| OpenCode | `~/.local/share/opencode` |
+| Commits | `git log` in the repos under your usual folders, for the addresses you list |
+
+## What it sends
+
+Per day and tool: message, tool-call, session and token counts, and model names.
+Per commit you authored: a keyed hash of its id, its day, and the AI agent named
+in its co-author trailer. Never prompts, responses, code, file paths, repo names,
+commit messages or email addresses. `npx vibestreak collect --json` prints the
+exact upload without sending it.
+
+## Requirements
+
+Node.js 22.13 or newer and git, on macOS, Linux or Windows. Background syncs use
+the system's own scheduler: launchd (macOS), systemd user timers or crontab
+(Linux), Task Scheduler (Windows). The evening streak check notifies through
+Notification Center, `notify-send`, or a Windows toast.

package/bin/vibestreak.mjs

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+import { fileURLToPath } from 'node:url'
+import { parseArgs } from 'node:util'
+
+import { installAutosync, removeAutosync } from '../src/autosync.mjs'
+import { notify, nudgeText, shouldNudge } from '../src/nudge.mjs'
+import { collect, sinceDate, summarize } from '../src/collect.mjs'
+import { CONFIG_PATH, loadConfig, saveConfig } from '../src/config.mjs'
+import { DEFAULT_ROOTS, globalEmail, scanEmails } from '../src/git.mjs'
+
+const BRAND = process.env.VIBESTREAK_BRAND ?? 'vibestreak'
+const DEFAULT_SERVER = process.env.VIBESTREAK_SERVER ?? 'https://vibestreak.kingsbridge-consultancy.com'
+
+const HELP = `${BRAND} — share your AI coding heatmap: what you shipped, and how steadily.
+
+  ${BRAND} collect [--json]          preview what would be sent (nothing leaves the machine)
+  ${BRAND} login --token <t> [--server <url>]
+                                     link this machine (token from your settings page)
+  ${BRAND} sync [--quiet]            collect and upload daily totals
+  ${BRAND} emails [scan|add <e>|remove <e>]
+                                     the addresses you commit as (all of your accounts)
+  ${BRAND} roots [add <dir>|remove <dir>]
+                                     where to look for git repos
+  ${BRAND} autosync [on|off]         sync in the background through the day
+  ${BRAND} nudge [on|off|test]       an evening notification when your streak is
+                                     about to end (on with autosync)
+  ${BRAND} whoami                    the profile this machine syncs to
+
+Reads: Claude Code, Codex, Cursor, Copilot (CLI and VS Code), Gemini CLI,
+Antigravity and OpenCode history, and git.
+Sent: per day and tool, message, tool-call, session and token counts and model
+names; per commit you authored, a keyed hash, its day and the AI agent named in
+its co-author trailer. Never prompts, code, file paths, repo names or messages.
+Config: ${CONFIG_PATH}
+All commands, with examples: ${DEFAULT_SERVER}/cli`
+
+const fmt = n => n.toLocaleString('en-US')
+
+async function api(config, path, init = {}) {
+  if (!config.server || !config.token) throw new Error(`Not linked yet: run \`${BRAND} login --token <token>\`.`)
+  const response = await fetch(new URL(path, config.server), {
+    ...init,
+    headers: { authorization: `Bearer ${config.token}`, 'content-type': 'application/json', ...init.headers },
+  })
+  const body = await response.json().catch(() => ({}))
+  if (!response.ok) throw new Error(body.error ?? `${response.status} ${response.statusText}`)
+  return body
+}
+
+async function main() {
+  const { positionals, values } = parseArgs({
+    allowPositionals: true,
+    options: {
+      json: { type: 'boolean' },
+      quiet: { type: 'boolean' },
+      token: { type: 'string' },
+      server: { type: 'string' },
+      since: { type: 'string' },
+      help: { type: 'boolean', short: 'h' },
+    },
+  })
+  const [command = 'help', ...rest] = positionals
+  const config = await loadConfig()
+  const log = (...args) => values.quiet || console.log(...args)
+
+  if (command === 'help' || values.help) return console.log(HELP)
+
+  if (command === 'emails') {
+    const [action, email] = rest
+    if (!config.emails.length) {
+      const first = await globalEmail()
+      if (first) config.emails = [first]
+    }
+    if (action === 'add' && email) config.emails = [...new Set([...config.emails, email])]
+    if (action === 'remove' && email) config.emails = config.emails.filter(e => e !== email)
+    if (action === 'scan') {
+      console.log('Author addresses in your repos (last 400 days); add each one that is you:\n')
+      for (const [address, count] of await scanEmails({ roots: config.roots ?? DEFAULT_ROOTS, since: sinceDate() })) {
+        console.log(`  ${config.emails.includes(address) ? '✓' : ' '} ${String(count).padStart(6)}  ${address}`)
+      }
+      console.log(`\n  ${BRAND} emails add <address>`)
+    }
+    await saveConfig(config)
+    if (action !== 'scan') console.log(config.emails.length ? config.emails.join('\n') : 'No addresses yet.')
+    return
+  }
+
+  if (command === 'roots') {
+    const [action, dir] = rest
+    const roots = config.roots ?? DEFAULT_ROOTS
+    if (action === 'add' && dir) config.roots = [...new Set([...roots, dir])]
+    if (action === 'remove' && dir) config.roots = roots.filter(r => r !== dir)
+    await saveConfig(config)
+    return console.log((config.roots ?? DEFAULT_ROOTS).join('\n'))
+  }
+
+  if (command === 'login') {
+    if (!values.token) return console.log(`Get a token on ${values.server ?? config.server ?? DEFAULT_SERVER}/settings, then:\n  ${BRAND} login --token <token>`)
+    config.server = values.server ?? config.server ?? DEFAULT_SERVER
+    config.token = values.token
+    const me = await api(config, '/api/v1/me')
+    if (!config.emails.length) {
+      const first = await globalEmail()
+      if (first) config.emails = [first]
+    }
+    await saveConfig(config)
+    console.log(`Linked ${config.machineName} to ${me.handle} (${me.profileUrl}).`)
+    console.log(`Commit addresses: ${config.emails.join(', ') || 'none'}; run \`${BRAND} emails scan\` to add your other accounts.`)
+    return
+  }
+
+  if (command === 'whoami') {
+    const me = await api(config, '/api/v1/me')
+    return console.log(`${me.handle} · ${me.profileUrl}\nGitHub: ${me.github.join(', ')}\nMachine: ${config.machineName}`)
+  }
+
+  if (command === 'collect' || command === 'sync') return sync(config, values, log, command === 'sync')
+
+  if (command === 'nudge') {
+    const bin = fileURLToPath(import.meta.url)
+    if (rest[0] === 'on' || rest[0] === 'off') {
+      config.nudge = rest[0] === 'on'
+      await saveConfig(config)
+      if (config.autosync) await installAutosync(bin, { nudge: config.nudge })
+      return console.log(`Streak nudge ${config.nudge ? 'on: 20:30 each evening when your streak is at risk' : 'off'}.`)
+    }
+    if (rest[0] === 'test') {
+      const { streak } = await api(config, '/api/v1/me')
+      await notify(nudgeText({ ...streak, current: Math.max(1, streak.current) }))
+      return console.log(`Sent a test notification (your streak: ${streak.current} days; ${streak.activeToday ? 'active today' : 'not active yet today'}).`)
+    }
+    // The evening run: sync, then nudge if the streak would end at midnight.
+    const result = await sync(config, values, log, true)
+    if (shouldNudge(result.streak, config)) {
+      await notify(nudgeText(result.streak))
+      config.lastNudge = result.streak.today
+      await saveConfig(config)
+      console.log(`${new Date().toISOString()} nudged: ${result.streak.current}-day streak at risk`)
+    }
+    return
+  }
+
+  if (command === 'autosync') {
+    if (rest[0] === 'off') {
+      config.autosync = false
+      await saveConfig(config)
+      return console.log(await removeAutosync())
+    }
+    const result = await installAutosync(fileURLToPath(import.meta.url), { nudge: config.nudge !== false })
+    config.autosync = result.installed
+    await saveConfig(config)
+    return console.log(
+      result.installed
+        ? `Syncing at ${result.times.join(', ')} via ${result.using}${result.nudgeAt ? `; streak check at ${result.nudgeAt}` : ''}. Log: ${result.log}`
+        : result.hint,
+    )
+  }
+
+  console.log(HELP)
+  process.exitCode = 1
+}
+
+// Collects this machine's totals and, for a sync, uploads them; the server
+// answers with where the streak stands (the nudge's input).
+async function sync(config, values, log, isSync) {
+  const me = isSync ? await api(config, '/api/v1/me') : undefined
+  const emails = [...new Set([...config.emails, ...(me?.emails ?? [])])]
+  if (!emails.length) {
+    const first = await globalEmail()
+    if (first) emails.push(first)
+  }
+  const started = Date.now()
+  const payload = await collect({ config: { ...config, emails }, salt: me?.salt ?? config.localSalt, since: values.since })
+  if (values.json) return console.log(JSON.stringify(payload, null, 2))
+  const s = summarize(payload)
+  log(`${s.activeDays} active days since ${payload.since} (${((Date.now() - started) / 1000).toFixed(1)}s)`)
+  for (const [tool, t] of Object.entries(s.tools)) {
+    log(`  ${tool.padEnd(11)} ${String(t.days).padStart(4)} days  ${fmt(t.messages).padStart(10)} messages  ${fmt(t.toolCalls).padStart(9)} tool calls  ${fmt(t.tokens).padStart(16)} tokens`)
+  }
+  log(`  ${'commits'.padEnd(11)} ${fmt(s.commits)} by you in ${s.repos} repos, ${fmt(s.aiCommits)} with an AI co-author (${emails.join(', ') || 'no addresses'})`)
+  if (!isSync) return log(`\nNothing was sent. \`${BRAND} sync\` uploads these totals.`)
+  const result = await api(config, '/api/v1/upload', { method: 'POST', body: JSON.stringify(payload) })
+  config.lastSync = new Date().toISOString()
+  await saveConfig(config)
+  // Always one line, quiet or not: the background sync's log is how a person sees it ran.
+  const streak = result.streak ? ` · streak ${result.streak.current}d${result.streak.activeToday ? '' : ' (not yet today)'}` : ''
+  console.log(`${config.lastSync} uploaded ${result.days} days, ${result.commits} commits from ${s.repos} repos${streak} → ${result.profileUrl}`)
+  return result
+}
+
+main().catch(error => {
+  console.error(`${BRAND}: ${error.message}`)
+  process.exitCode = 1
+})

package/package.json

@@ -1,6 +1,15 @@
 {
   "name": "vibestreak",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Your AI coding streak: a heatmap of the days you coded with Claude Code, Codex, Cursor, Copilot, Gemini and OpenCode, and the commits you shipped with them. Sends daily totals only.",
+  "keywords": ["claude-code", "codex", "cursor", "copilot", "gemini", "opencode", "ai-coding", "heatmap", "streak", "leaderboard", "cli"],
+  "homepage": "https://vibestreak.kingsbridge-consultancy.com/cli",
+  "license": "MIT",
+  "author": "Kingsbridge Consultancy LLC <support@kingsbridge-consultancy.com>",
+  "type": "module",
+  "bin": { "vibestreak": "bin/vibestreak.mjs" },
+  "files": ["bin", "src", "README.md", "LICENSE"],
+  "engines": { "node": ">=22.13" },
+  "os": ["darwin", "linux", "win32"],
+  "scripts": { "test": "node --test test/*.test.mjs" }
+}

package/src/autosync.mjs

@@ -0,0 +1,231 @@
+import { execFile } from 'node:child_process'
+import { cp, mkdir, rm, writeFile } from 'node:fs/promises'
+import { homedir, platform } from 'node:os'
+import { dirname, join } from 'node:path'
+import { promisify } from 'node:util'
+
+import { CONFIG_PATH } from './config.mjs'
+
+const run = promisify(execFile)
+
+// Syncs through the day keep the Today board current; the evening run also
+// checks whether the streak is about to end (`vibestreak nudge`).
+export const SYNC_TIMES = [
+  [9, 17],
+  [13, 17],
+  [17, 17],
+]
+export const NUDGE_TIME = [20, 30]
+
+export const clock = ([h, m]) => `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}`
+const configDir = () => dirname(CONFIG_PATH)
+const logPath = () => join(configDir(), 'sync.log')
+
+// The jobs to schedule: a sync at each sync time, and the evening nudge.
+export const jobs = nudge => [
+  { name: 'sync', args: ['sync', '--quiet'], times: SYNC_TIMES },
+  ...(nudge ? [{ name: 'nudge', args: ['nudge', '--quiet'], times: [NUDGE_TIME] }] : []),
+]
+
+// A CLI run through npx lives in npm's cache, which can be cleared; a
+// scheduled job needs a copy that stays put, so autosync keeps one in the
+// config folder (refreshed by every `autosync on`).
+export async function stableBin(bin) {
+  if (!/[/\\](_npx|npm-cache)[/\\]/.test(bin)) return bin
+  const pkg = dirname(dirname(bin))
+  const home = join(configDir(), 'cli')
+  await rm(home, { recursive: true, force: true })
+  await cp(pkg, home, { recursive: true, filter: src => !/[/\\](node_modules|test)([/\\]|$)/.test(src.slice(pkg.length)) })
+  return join(home, 'bin', 'vibestreak.mjs')
+}
+
+// --- macOS: launchd agents ------------------------------------------------
+
+const LAUNCHD = { sync: 'dev.vibestreak.sync', nudge: 'dev.vibestreak.nudge' }
+const agents = () => join(homedir(), 'Library', 'LaunchAgents')
+
+export function launchdPlist(label, node, bin, args, times, log) {
+  const intervals = times.map(([h, m]) => `<dict><key>Hour</key><integer>${h}</integer><key>Minute</key><integer>${m}</integer></dict>`).join('')
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${label}</string>
+  <key>ProgramArguments</key>
+  <array><string>${node}</string><string>${bin}</string>${args.map(a => `<string>${a}</string>`).join('')}</array>
+  <key>StartCalendarInterval</key>
+  <array>${intervals}</array>
+  <key>RunAtLoad</key><false/>
+  <key>StandardOutPath</key><string>${log}</string>
+  <key>StandardErrorPath</key><string>${log}</string>
+</dict>
+</plist>
+`
+}
+
+const launchd = {
+  async install(node, bin, nudge) {
+    await mkdir(agents(), { recursive: true })
+    for (const job of jobs(true)) {
+      const plist = join(agents(), `${LAUNCHD[job.name]}.plist`)
+      await run('launchctl', ['unload', plist]).catch(() => {})
+      if (job.name === 'nudge' && !nudge) {
+        await rm(plist, { force: true })
+        continue
+      }
+      await writeFile(plist, launchdPlist(LAUNCHD[job.name], node, bin, job.args, job.times, logPath()))
+      await run('launchctl', ['load', plist])
+    }
+    return 'launchd'
+  },
+  async remove() {
+    for (const label of Object.values(LAUNCHD)) {
+      const plist = join(agents(), `${label}.plist`)
+      await run('launchctl', ['unload', plist]).catch(() => {})
+      await rm(plist, { force: true })
+    }
+  },
+}
+
+// --- Linux: systemd user timers, else crontab -------------------------------
+
+const units = () => join(process.env.XDG_CONFIG_HOME || join(homedir(), '.config'), 'systemd', 'user')
+// systemd's own quoting: backslash-escaped quotes and backslashes, and $ and %
+// (its variables and specifiers) doubled.
+const quoteArg = a => `"${a.replace(/(["\\])/g, '\\$1').replace(/\$/g, '$$$$').replace(/%/g, '%%')}"`
+
+export function systemdUnits(node, bin, job, log) {
+  const calendar = job.times.map(t => `OnCalendar=*-*-* ${clock(t)}:00`).join('\n')
+  return {
+    service: `[Unit]
+Description=vibestreak ${job.name}
+
+[Service]
+Type=oneshot
+ExecStart=${[node, bin, ...job.args].map(quoteArg).join(' ')}
+StandardOutput=append:${log}
+StandardError=append:${log}
+`,
+    // Persistent: a run missed while the machine slept happens when it wakes.
+    timer: `[Unit]
+Description=vibestreak ${job.name} schedule
+
+[Timer]
+${calendar}
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+`,
+  }
+}
+
+const CRON_BEGIN = '# vibestreak:begin'
+const CRON_END = '# vibestreak:end'
+const shellQuote = a => `'${a.replace(/'/g, `'\\''`)}'`
+
+export function cronBlock(node, bin, nudge, log) {
+  const lines = jobs(nudge).flatMap(job =>
+    job.times.map(([h, m]) => `${m} ${h} * * * ${[node, bin, ...job.args].map(shellQuote).join(' ')} >> ${shellQuote(log)} 2>&1`),
+  )
+  return [CRON_BEGIN, ...lines, CRON_END].join('\n')
+}
+
+// The crontab with our block replaced (or removed, given no block).
+export const withCronBlock = (current, block) => {
+  const kept = current.replace(new RegExp(`\\n?${CRON_BEGIN}[\\s\\S]*?${CRON_END}\\n?`, 'g'), '\n').trim()
+  return `${[kept, block].filter(Boolean).join('\n')}\n`
+}
+
+async function writeCrontab(block) {
+  const current = await run('crontab', ['-l']).then(r => r.stdout, () => '')
+  await new Promise((resolve, reject) => {
+    const child = execFile('crontab', ['-'], error => (error ? reject(error) : resolve()))
+    child.stdin.end(withCronBlock(current, block))
+  })
+}
+
+const hasUserSystemd = () => run('systemctl', ['--user', 'show-environment']).then(() => true, () => false)
+
+const linux = {
+  async install(node, bin, nudge) {
+    if (await hasUserSystemd()) {
+      await mkdir(units(), { recursive: true })
+      for (const job of jobs(true)) {
+        const name = `vibestreak-${job.name}`
+        if (job.name === 'nudge' && !nudge) {
+          await run('systemctl', ['--user', 'disable', '--now', `${name}.timer`]).catch(() => {})
+          await rm(join(units(), `${name}.timer`), { force: true })
+          await rm(join(units(), `${name}.service`), { force: true })
+          continue
+        }
+        const { service, timer } = systemdUnits(node, bin, job, logPath())
+        await writeFile(join(units(), `${name}.service`), service)
+        await writeFile(join(units(), `${name}.timer`), timer)
+      }
+      await run('systemctl', ['--user', 'daemon-reload'])
+      for (const job of jobs(nudge)) await run('systemctl', ['--user', 'enable', '--now', `vibestreak-${job.name}.timer`])
+      return 'systemd'
+    }
+    await writeCrontab(cronBlock(node, bin, nudge, logPath()))
+    return 'crontab'
+  },
+  async remove() {
+    for (const name of ['vibestreak-sync', 'vibestreak-nudge']) {
+      await run('systemctl', ['--user', 'disable', '--now', `${name}.timer`]).catch(() => {})
+      await rm(join(units(), `${name}.timer`), { force: true })
+      await rm(join(units(), `${name}.service`), { force: true })
+    }
+    await run('systemctl', ['--user', 'daemon-reload']).catch(() => {})
+    await writeCrontab('').catch(() => {})
+  },
+}
+
+// --- Windows: Task Scheduler ------------------------------------------------
+
+// Each task runs a small .cmd in the config folder, so the command (and its
+// log redirect) has no length limit and no quoting inside schtasks.
+export const windowsTaskName = (job, [h, m]) => `vibestreak\\${job.name}-${String(h).padStart(2, '0')}${String(m).padStart(2, '0')}`
+const cmdPath = p => p.replace(/%/g, '%%')
+export const windowsScript = (node, bin, job, log) => `@echo off\r\n"${cmdPath(node)}" "${cmdPath(bin)}" ${job.args.join(' ')} >> "${cmdPath(log)}" 2>&1\r\n`
+
+const ALL_WINDOWS_TASKS = jobs(true).flatMap(job => job.times.map(t => windowsTaskName(job, t)))
+
+const windows = {
+  async install(node, bin, nudge) {
+    await windows.remove()
+    await mkdir(configDir(), { recursive: true })
+    for (const job of jobs(nudge)) {
+      const script = join(configDir(), `${job.name}.cmd`)
+      await writeFile(script, windowsScript(node, bin, job, logPath()))
+      for (const time of job.times) {
+        await run('schtasks', ['/Create', '/F', '/SC', 'DAILY', '/ST', clock(time), '/TN', windowsTaskName(job, time), '/TR', `"${script}"`])
+      }
+    }
+    return 'Task Scheduler'
+  },
+  async remove() {
+    for (const name of ALL_WINDOWS_TASKS) await run('schtasks', ['/Delete', '/F', '/TN', name]).catch(() => {})
+  },
+}
+
+const SCHEDULERS = { darwin: launchd, linux, win32: windows }
+
+// Schedules the background syncs (and the evening nudge) with the system's
+// own scheduler.
+export async function installAutosync(bin, { nudge = true } = {}) {
+  const scheduler = SCHEDULERS[platform()]
+  const times = SYNC_TIMES.map(clock)
+  const nudgeAt = nudge ? clock(NUDGE_TIME) : undefined
+  if (!scheduler) {
+    return { installed: false, hint: `No scheduler support on ${platform()} yet. Run \`${bin} sync --quiet\` at ${times.join(', ')}${nudge ? ` and \`nudge --quiet\` at ${nudgeAt}` : ''}.` }
+  }
+  await mkdir(configDir(), { recursive: true })
+  const using = await scheduler.install(process.execPath, await stableBin(bin), nudge)
+  return { installed: true, using, times, nudgeAt, log: logPath() }
+}
+
+export async function removeAutosync() {
+  await SCHEDULERS[platform()]?.remove()
+  return { removed: true }
+}

package/src/claude.mjs

@@ -0,0 +1,83 @@
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+import { dayOfIso, emptyDay } from './days.mjs'
+import { lines, walk } from './files.mjs'
+
+// Claude Code keeps every session as JSONL under ~/.claude/projects (subagents
+// included). Lines are matched with regular expressions rather than parsed:
+// a heavy user has gigabytes of transcripts, and the fields needed sit at the
+// top level of each row.
+//
+// - A message is a user or assistant row; a row copied into another file (a
+//   fork, a resume) keeps its uuid and is counted once.
+// - One API request is written as several assistant rows repeating its usage,
+//   so tokens count once per requestId, on the day of its first row, each
+//   field at its largest.
+const ROLE = /"type":"(user|assistant)"/
+const TIMESTAMP = /"timestamp":"([^"]+)"/
+const UUID = /"uuid":"([0-9a-f-]{36})"/
+const SESSION = /"sessionId":"([^"]+)"/
+const REQUEST = /"requestId":"([^"]+)"/
+const MODEL = /"model":"((?:claude|gpt|gemini)[^"]*)"/
+const TOOL_USE = /"type":"tool_use"/g
+const USAGE = {
+  input: /"input_tokens":(\d+)/,
+  output: /"output_tokens":(\d+)/,
+  cacheRead: /"cache_read_input_tokens":(\d+)/,
+  cacheWrite: /"cache_creation_input_tokens":(\d+)/,
+}
+
+export async function collectClaude({ root = join(homedir(), '.claude', 'projects'), since } = {}) {
+  const days = new Map()
+  const seen = new Set()
+  const sessions = new Map()
+  const requests = new Map()
+  const day = date => {
+    if (!days.has(date)) days.set(date, { ...emptyDay(date, 'claude'), models: new Set() })
+    return days.get(date)
+  }
+
+  for await (const path of walk(root, '.jsonl')) {
+    for await (const line of lines(path)) {
+      const role = ROLE.exec(line)?.[1]
+      if (!role) continue
+      const date = dayOfIso(TIMESTAMP.exec(line)?.[1] ?? '')
+      if (!date || (since && date < since)) continue
+      const uuid = UUID.exec(line)?.[1]
+      if (uuid) {
+        if (seen.has(uuid)) continue
+        seen.add(uuid)
+      }
+      const counts = day(date)
+      counts.messages++
+      counts.toolCalls += line.match(TOOL_USE)?.length ?? 0
+      const session = SESSION.exec(line)?.[1]
+      if (session) {
+        if (!sessions.has(date)) sessions.set(date, new Set())
+        sessions.get(date).add(session)
+      }
+      if (role !== 'assistant') continue
+      const model = MODEL.exec(line)?.[1]
+      if (model && model !== '<synthetic>') counts.models.add(model)
+      const request = REQUEST.exec(line)?.[1]
+      if (!request) continue
+      const usage = requests.get(request) ?? { date, input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }
+      for (const [field, pattern] of Object.entries(USAGE)) {
+        const value = Number(pattern.exec(line)?.[1] ?? 0)
+        if (value > usage[field]) usage[field] = value
+      }
+      requests.set(request, usage)
+    }
+  }
+
+  for (const { date, ...usage } of requests.values()) {
+    const counts = day(date)
+    for (const field of Object.keys(USAGE)) counts[field] += usage[field]
+  }
+  for (const [date, ids] of sessions) day(date).sessions = ids.size
+
+  return [...days.values()]
+    .map(d => ({ ...d, models: [...d.models].sort() }))
+    .sort((a, b) => a.date.localeCompare(b.date))
+}