vibestreak 0.1.1 → 0.2.0

package/bin/vibestreak.mjs

@@ -2,17 +2,25 @@
 import { fileURLToPath } from 'node:url'
 import { parseArgs } from 'node:util'
 
-import { autosyncStatus, clock, installAutosync, NUDGE_TIME, nextRun, removeAutosync, SYNC_TIMES } from '../src/autosync.mjs'
-import { notify, nudgeAction, nudgeText, shouldNudge } from '../src/nudge.mjs'
-import { collect, sinceDate, summarize } from '../src/collect.mjs'
+import { autosyncStatus, clock, installAutosync, nextRun, removeAutosync, SYNC_TIMES } from '../src/autosync.mjs'
+import { NUDGE_DEFAULT, notify, nudgeAction, nudgeText, nudgeTimeOf, parseNudgeTime, shouldNudge } from '../src/nudge.mjs'
+import { collect, sinceDate, summarize, syncSince } from '../src/collect.mjs'
 import { CONFIG_PATH, loadConfig, saveConfig } from '../src/config.mjs'
 import { DEFAULT_ROOTS, globalEmail, scanEmails } from '../src/git.mjs'
+import { boardView, dashboardView, profileView, todayView } from '../src/views.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}                           your streak, heatmap and rank at a glance
+  ${BRAND} me                        your profile: streak, heatmap, totals
+  ${BRAND} profile <handle>          someone else's public profile
+  ${BRAND} board [today|7d|30d|90d|all] [consistency|shipped|streak|tokens] [tool]
+                                     the leaderboard (--from/--to for your own dates)
+  ${BRAND} today                     who is coding with AI today; streaks at risk
+
   ${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)
@@ -25,6 +33,7 @@ const HELP = `${BRAND} — share your AI coding heatmap: what you shipped, and h
   ${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); alone, its status
+  ${BRAND} nudge at 21:45            when it checks (17:00 to 23:30; default 20:30)
   ${BRAND} whoami                    the profile this machine syncs to
 
 Reads: Claude Code, Codex, Cursor, Copilot (CLI and VS Code), Gemini CLI,
@@ -57,14 +66,40 @@ async function main() {
       token: { type: 'string' },
       server: { type: 'string' },
       since: { type: 'string' },
+      full: { type: 'boolean' },
       help: { type: 'boolean', short: 'h' },
+      from: { type: 'string' },
+      to: { type: 'string' },
+      limit: { type: 'string' },
     },
   })
-  const [command = 'help', ...rest] = positionals
+  const [command = 'dashboard', ...rest] = positionals
   const config = await loadConfig()
   const log = (...args) => values.quiet || console.log(...args)
 
   if (command === 'help' || values.help) return console.log(HELP)
+  const columns = process.stdout.columns || 100
+  const server = config.server ?? DEFAULT_SERVER
+
+  if (command === 'dashboard') {
+    // Plain `vibestreak`: the dashboard once linked; before that, how to start.
+    if (!config.token) return console.log(`${HELP}\n\nGet started: ${server.replace(/\/$/, '')}/cli`)
+    const me = await api(config, '/api/v1/me')
+    return dashboardView({ server, token: config.token, handle: me.handle, columns })
+  }
+  if (command === 'me') {
+    const me = await api(config, '/api/v1/me')
+    return profileView({ server, token: config.token, handle: me.handle, columns })
+  }
+  if (command === 'profile') {
+    if (!rest[0]) throw new Error(`Whose? \`${BRAND} profile <handle>\` (yours: \`${BRAND} me\`).`)
+    return profileView({ server, token: config.token, handle: rest[0].replace(/^@/, ''), columns })
+  }
+  if (command === 'board') {
+    const you = config.token ? (await api(config, '/api/v1/me').catch(() => null))?.handle : undefined
+    return boardView({ server, words: rest, values, you, columns })
+  }
+  if (command === 'today') return todayView({ server })
 
   if (command === 'emails') {
     const [action, email] = rest
@@ -123,11 +158,21 @@ async function main() {
     const bin = fileURLToPath(import.meta.url)
     const action = nudgeAction(rest, values)
     if (action === 'status') return nudgeStatus(config)
+    if (action === 'at') {
+      const time = parseNudgeTime(rest[1])
+      config.nudgeTime = clock(time)
+      if (rest[1].trim().toLowerCase() === 'default') delete config.nudgeTime
+      await saveConfig(config)
+      const scheduled = await autosyncStatus()
+      if (scheduled.on && config.nudge !== false) await installAutosync(bin, { nudge: true, nudgeTime: time })
+      const note = config.nudge === false ? ` It's off: \`${BRAND} nudge on\` turns it on.` : !scheduled.on ? ` It runs once autosync is on: \`${BRAND} autosync on\`.` : ''
+      return console.log(`Streak check at ${clock(time)}${clock(time) === clock(NUDGE_DEFAULT) ? ' (the default)' : ''}.${note}`)
+    }
     if (action === 'on' || action === 'off') {
       config.nudge = action === '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 (config.autosync) await installAutosync(bin, { nudge: config.nudge, nudgeTime: nudgeTimeOf(config) })
+      return console.log(`Streak nudge ${config.nudge ? `on: ${clock(nudgeTimeOf(config))} each evening when your streak is at risk` : 'off'}.`)
     }
     if (action === 'test') {
       const { streak } = await api(config, '/api/v1/me')
@@ -151,7 +196,7 @@ async function main() {
       await saveConfig(config)
       return console.log(await removeAutosync())
     }
-    const result = await installAutosync(fileURLToPath(import.meta.url), { nudge: config.nudge !== false })
+    const result = await installAutosync(fileURLToPath(import.meta.url), { nudge: config.nudge !== false, nudgeTime: nudgeTimeOf(config) })
     config.autosync = result.installed
     await saveConfig(config)
     return console.log(
@@ -175,7 +220,7 @@ async function sync(config, values, log, isSync) {
     if (first) emails.push(first)
   }
   const started = Date.now()
-  const payload = await collect({ config: { ...config, emails }, salt: me?.salt ?? config.localSalt, since: values.since })
+  const payload = await collect({ config: { ...config, emails }, salt: me?.salt ?? config.localSalt, since: isSync ? syncSince(config, values) : 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)`)
@@ -186,7 +231,9 @@ async function sync(config, values, log, isSync) {
   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()
+  config.lastSyncServer = config.server
   config.lastSyncSummary = { days: result.days, commits: result.commits, repos: s.repos }
+  if (result.underReview) console.log(`Your profile is under review and off the boards for now: see ${new URL('/settings#trust', config.server)}`)
   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)'}` : ''
@@ -222,11 +269,12 @@ async function nudgeStatus(config) {
   const [scheduled, me] = await Promise.all([autosyncStatus(), serverStatus(config)])
   const on = config.nudge !== false && scheduled.nudge
   const why = config.nudge === false ? ` (\`${BRAND} nudge on\` turns it on)` : !scheduled.on ? ` (needs autosync: \`${BRAND} autosync on\`)` : ''
-  console.log(`Nudge       ${on ? `on · checks at ${clock(NUDGE_TIME)}` : `off${why}`}`)
+  const time = clock(nudgeTimeOf(config))
+  console.log(`Nudge       ${on ? `on · checks at ${time}${config.nudgeTime ? '' : ' (default; `nudge at 21:45` changes it)'}` : `off${why}`}`)
   console.log(`Last nudge  ${config.lastNudge ?? 'never'}`)
   if (me.error) return console.log(`Tonight     unknown (${me.error})`)
   const s = me.streak
-  const tonight = !on ? 'no check' : s.activeToday ? 'no nudge: you were active today' : s.current > 0 ? (config.lastNudge === s.today ? 'already nudged today' : `will nudge at ${clock(NUDGE_TIME)} unless you code with AI first`) : 'no nudge: no live streak'
+  const tonight = !on ? 'no check' : s.activeToday ? 'no nudge: you were active today' : s.current > 0 ? (config.lastNudge === s.today ? 'already nudged today' : `will nudge at ${time} unless you code with AI first`) : 'no nudge: no live streak'
   console.log(`Streak      ${streakLine(s)}`)
   console.log(`Tonight     ${tonight}`)
 }
@@ -242,7 +290,7 @@ async function status(config) {
   if (!me.error) row('Streak', streakLine(me.streak))
   row('Autosync', scheduled.on ? `on (${scheduled.using}) · next sync ${at(nextRun(SYNC_TIMES))}` : `off: \`${BRAND} autosync on\` syncs at ${SYNC_TIMES.map(clock).join(', ')}`)
   const nudgeOn = config.nudge !== false && scheduled.nudge
-  row('Nudge', nudgeOn ? `on · checks at ${clock(NUDGE_TIME)} · last nudged ${config.lastNudge ?? 'never'}` : config.nudge === false ? 'off' : 'off (needs autosync)')
+  row('Nudge', nudgeOn ? `on · checks at ${clock(nudgeTimeOf(config))} · last nudged ${config.lastNudge ?? 'never'}` : config.nudge === false ? 'off' : 'off (needs autosync)')
   const github = me.error ? 0 : (me.emails?.length ?? 0)
   row('Addresses', `${config.emails.join(', ') || 'none'}${github ? ` · +${github} from GitHub` : ''}`)
   row('Config', CONFIG_PATH)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibestreak",
-  "version": "0.1.1",
+  "version": "0.2.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",

package/src/autosync.mjs

@@ -6,6 +6,7 @@ import { dirname, join } from 'node:path'
 import { promisify } from 'node:util'
 
 import { CONFIG_PATH } from './config.mjs'
+import { NUDGE_DEFAULT } from './nudge.mjs'
 
 const run = promisify(execFile)
 
@@ -16,16 +17,17 @@ export const SYNC_TIMES = [
   [13, 17],
   [17, 17],
 ]
-export const NUDGE_TIME = [20, 30]
+export { NUDGE_DEFAULT as NUDGE_TIME }
 
 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 => [
+// The jobs to schedule: a sync at each sync time, and the evening nudge at
+// the person's chosen time.
+export const jobs = (nudge, nudgeTime = NUDGE_DEFAULT) => [
   { name: 'sync', args: ['sync', '--quiet'], times: SYNC_TIMES },
-  ...(nudge ? [{ name: 'nudge', args: ['nudge', 'run', '--quiet'], times: [NUDGE_TIME] }] : []),
+  ...(nudge ? [{ name: 'nudge', args: ['nudge', 'run', '--quiet'], times: [nudgeTime] }] : []),
 ]
 
 // A CLI run through npx lives in npm's cache, which can be cleared; a
@@ -65,9 +67,9 @@ export function launchdPlist(label, node, bin, args, times, log) {
 }
 
 const launchd = {
-  async install(node, bin, nudge) {
+  async install(node, bin, nudge, nudgeTime) {
     await mkdir(agents(), { recursive: true })
-    for (const job of jobs(true)) {
+    for (const job of jobs(true, nudgeTime)) {
       const plist = join(agents(), `${LAUNCHD[job.name]}.plist`)
       await run('launchctl', ['unload', plist]).catch(() => {})
       if (job.name === 'nudge' && !nudge) {
@@ -129,8 +131,8 @@ 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 =>
+export function cronBlock(node, bin, nudge, log, nudgeTime) {
+  const lines = jobs(nudge, nudgeTime).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')
@@ -153,10 +155,10 @@ async function writeCrontab(block) {
 const hasUserSystemd = () => run('systemctl', ['--user', 'show-environment']).then(() => true, () => false)
 
 const linux = {
-  async install(node, bin, nudge) {
+  async install(node, bin, nudge, nudgeTime) {
     if (await hasUserSystemd()) {
       await mkdir(units(), { recursive: true })
-      for (const job of jobs(true)) {
+      for (const job of jobs(true, nudgeTime)) {
         const name = `vibestreak-${job.name}`
         if (job.name === 'nudge' && !nudge) {
           await run('systemctl', ['--user', 'disable', '--now', `${name}.timer`]).catch(() => {})
@@ -172,7 +174,7 @@ const linux = {
       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()))
+    await writeCrontab(cronBlock(node, bin, nudge, logPath(), nudgeTime))
     return 'crontab'
   },
   async status() {
@@ -202,13 +204,18 @@ export const windowsTaskName = (job, [h, m]) => `vibestreak\\${job.name}-${Strin
 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)))
+// Our tasks as Task Scheduler holds them, whatever times they were made for.
+async function windowsTasks() {
+  const { stdout } = await run('schtasks', ['/Query', '/FO', 'CSV', '/NH']).catch(() => ({ stdout: '' }))
+  const names = stdout.split(/\r?\n/).map(line => /^"([^"]+)"/.exec(line)?.[1]).filter(Boolean)
+  return [...new Set(names.filter(n => /^\\vibestreak\\/i.test(n)).map(n => n.slice(1)))]
+}
 
 const windows = {
-  async install(node, bin, nudge) {
+  async install(node, bin, nudge, nudgeTime) {
     await windows.remove()
     await mkdir(configDir(), { recursive: true })
-    for (const job of jobs(nudge)) {
+    for (const job of jobs(nudge, nudgeTime)) {
       const script = join(configDir(), `${job.name}.cmd`)
       await writeFile(script, windowsScript(node, bin, job, logPath()))
       for (const time of job.times) {
@@ -218,12 +225,11 @@ const windows = {
     return 'Task Scheduler'
   },
   async status() {
-    const has = name => run('schtasks', ['/Query', '/TN', name]).then(() => true, () => false)
-    const [syncJob, nudgeJob] = jobs(true)
-    return { on: await has(windowsTaskName(syncJob, syncJob.times[0])), using: 'Task Scheduler', nudge: await has(windowsTaskName(nudgeJob, NUDGE_TIME)) }
+    const names = await windowsTasks()
+    return { on: names.some(n => /\\sync-/i.test(n)), using: 'Task Scheduler', nudge: names.some(n => /\\nudge-/i.test(n)) }
   },
   async remove() {
-    for (const name of ALL_WINDOWS_TASKS) await run('schtasks', ['/Delete', '/F', '/TN', name]).catch(() => {})
+    for (const name of await windowsTasks()) await run('schtasks', ['/Delete', '/F', '/TN', name]).catch(() => {})
   },
 }
 
@@ -231,15 +237,15 @@ 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 } = {}) {
+export async function installAutosync(bin, { nudge = true, nudgeTime = NUDGE_DEFAULT } = {}) {
   const scheduler = SCHEDULERS[platform()]
   const times = SYNC_TIMES.map(clock)
-  const nudgeAt = nudge ? clock(NUDGE_TIME) : undefined
+  const nudgeAt = nudge ? clock(nudgeTime) : 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)
+  const using = await scheduler.install(process.execPath, await stableBin(bin), nudge, nudgeTime)
   return { installed: true, using, times, nudgeAt, log: logPath() }
 }
 

package/src/claude.mjs

@@ -38,7 +38,7 @@ export async function collectClaude({ root = join(homedir(), '.claude', 'project
     return days.get(date)
   }
 
-  for await (const path of walk(root, '.jsonl')) {
+  for await (const path of walk(root, '.jsonl', since)) {
     for await (const line of lines(path)) {
       const role = ROLE.exec(line)?.[1]
       if (!role) continue

package/src/codex.mjs

@@ -24,7 +24,7 @@ export async function collectCodex({ root = join(homedir(), '.codex'), since } =
   const seenSessions = new Set()
 
   for (const folder of ['sessions', 'archived_sessions']) {
-    for await (const path of walk(join(root, folder), '.jsonl')) {
+    for await (const path of walk(join(root, folder), '.jsonl', since)) {
       let session
       let model
       let last = { input: 0, cached: 0, output: 0 }

package/src/collect.mjs

@@ -9,8 +9,19 @@ import { collectOpenCode } from './opencode.mjs'
 
 export const PAYLOAD_VERSION = 1
 
-// How far back a sync reaches: a year and a bit, the most a heatmap shows.
-export const sinceDate = (days = 400) => dayKey(new Date(Date.now() - days * 864e5))
+// How far back a sync reaches: a machine's first sync sends a year and a
+// bit (the most a heatmap shows); after that the server takes only the last
+// week from it (its history lock), so later syncs send just that.
+export const FULL_DAYS = 400
+export const RECENT_DAYS = 7
+export const sinceDate = (days = FULL_DAYS) => dayKey(new Date(Date.now() - days * 864e5))
+
+// Where this machine's next sync starts: a full history the first time (or
+// on --full, or after linking to another server), the last week after that.
+export function syncSince(config, { full = false, since } = {}) {
+  if (since) return since
+  return full || !config.lastSync || config.lastSyncServer !== config.server ? sinceDate(FULL_DAYS) : sinceDate(RECENT_DAYS)
+}
 
 // Everything one machine sends: per-day totals per tool, and its commits as
 // keyed hashes. No prompt, code, path, repo name or commit message is read

package/src/files.mjs

@@ -1,8 +1,10 @@
-import { open, readdir } from 'node:fs/promises'
+import { open, readdir, stat } from 'node:fs/promises'
 import { join } from 'node:path'
 
-// Every file under `root` whose name ends in `suffix`, symbolic links not followed.
-export async function* walk(root, suffix) {
+// Every file under `root` whose name ends in `suffix`, symbolic links not
+// followed; with `since` (YYYY-MM-DD), only files changed on or after that
+// day (a file untouched since can hold nothing newer).
+export async function* walk(root, suffix, since) {
   let entries
   try {
     entries = await readdir(root, { withFileTypes: true })
@@ -11,11 +13,19 @@ export async function* walk(root, suffix) {
   }
   for (const entry of entries) {
     const path = join(root, entry.name)
-    if (entry.isDirectory()) yield* walk(path, suffix)
-    else if (entry.isFile() && entry.name.endsWith(suffix)) yield path
+    if (entry.isDirectory()) yield* walk(path, suffix, since)
+    else if (entry.isFile() && entry.name.endsWith(suffix)) {
+      if (since && (await stat(path).catch(() => undefined))?.mtime < localMidnight(since)) continue
+      yield path
+    }
   }
 }
 
+const localMidnight = day => {
+  const [y, m, d] = day.split('-').map(Number)
+  return new Date(y, m - 1, d)
+}
+
 const CHUNK = 4 * 1024 * 1024
 const NEWLINE = 10
 

package/src/google.mjs

@@ -27,7 +27,7 @@ const dayMap = tool => {
 // tool calls and tokens (`input` includes the cached part, split out here).
 export async function collectGeminiCli({ root = join(GEMINI(), 'tmp'), since } = {}) {
   const { day, list } = dayMap('gemini')
-  for await (const path of walk(root, '.json')) {
+  for await (const path of walk(root, '.json', since)) {
     if (!/[/\\]chats[/\\]/.test(path)) continue
     let chat
     try {
@@ -74,7 +74,7 @@ const seconds = buffer => {
 
 export async function collectAntigravity({ root = join(GEMINI(), 'antigravity', 'conversations'), since } = {}) {
   const { day, list } = dayMap('antigravity')
-  for await (const path of walk(root, '.db')) {
+  for await (const path of walk(root, '.db', since)) {
     const id = path
     const steps = await query(path, 'SELECT step_type AS type, hex(metadata) AS meta FROM steps')
     let lastDate

package/src/nudge.mjs

@@ -15,10 +15,52 @@ export function shouldNudge(streak, config) {
 // --quiet and nothing else it is the scheduled check as 0.1.0 installed it
 // (`nudge --quiet`), so those jobs keep working until autosync is rerun.
 export function nudgeAction(rest, values) {
-  if (['on', 'off', 'test', 'run'].includes(rest[0])) return rest[0]
+  if (['on', 'off', 'test', 'run', 'at'].includes(rest[0])) return rest[0]
   return values.quiet ? 'run' : 'status'
 }
 
+// When the evening check may run: late enough that the day is mostly done,
+// early enough to still code before midnight (streaks count calendar days).
+export const NUDGE_DEFAULT = [20, 30]
+export const NUDGE_EARLIEST = [17, 0]
+export const NUDGE_LATEST = [23, 30]
+const minutes = ([h, m]) => h * 60 + m
+const hhmm = ([h, m]) => `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}`
+
+// A time as people type it: 21:45, 2145, 9:45pm, 9pm, 21, or `default`.
+// Returns [hour, minute], or throws a sentence saying what to type instead.
+export function parseNudgeTime(input) {
+  const text = String(input ?? '').trim().toLowerCase().replace(/\s+/g, '')
+  if (text === 'default') return NUDGE_DEFAULT
+  const match = /^(\d{1,2})(?::?(\d{2}))?(am|pm)?$/.exec(text)
+  if (!match) throw new Error(`"${input}" is not a time: try 21:45 or 9:45pm.`)
+  let hour = Number(match[1])
+  const minute = Number(match[2] ?? 0)
+  if (match[3]) {
+    if (hour < 1 || hour > 12) throw new Error(`"${input}" is not a time: with am/pm the hour is 1 to 12.`)
+    hour = (hour % 12) + (match[3] === 'pm' ? 12 : 0)
+  }
+  if (hour > 23 || minute > 59) throw new Error(`"${input}" is not a time of day.`)
+  const time = [hour, minute]
+  if (minutes(time) < minutes(NUDGE_EARLIEST) || minutes(time) > minutes(NUDGE_LATEST)) {
+    // Small hours (before 5:00) mean 'late at night': the nearest is the latest allowed.
+    const nearest = minutes(time) < minutes(NUDGE_EARLIEST) && hour >= 5 ? NUDGE_EARLIEST : NUDGE_LATEST
+    throw new Error(
+      `The nudge runs between ${hhmm(NUDGE_EARLIEST)} and ${hhmm(NUDGE_LATEST)}: late enough that your day is mostly done, early enough to still code before midnight. The nearest is ${hhmm(nearest)}.`,
+    )
+  }
+  return time
+}
+
+// The person's chosen nudge time, or the default.
+export function nudgeTimeOf(config) {
+  try {
+    return config.nudgeTime ? parseNudgeTime(config.nudgeTime) : NUDGE_DEFAULT
+  } catch {
+    return NUDGE_DEFAULT
+  }
+}
+
 export function nudgeText(streak) {
   const days = streak.current === 1 ? '1-day streak' : `${streak.current}-day streak`
   const next = streak.next && streak.current + 1 >= streak.next.days ? ` Today makes it ${streak.next.name}.` : ''

package/src/opencode.mjs

@@ -73,7 +73,7 @@ export async function collectOpenCode({ dir = OPENCODE_DIR(), since } = {}) {
     }
     return n
   }
-  for await (const path of walk(join(storage, 'message'), '.json')) {
+  for await (const path of walk(join(storage, 'message'), '.json', since)) {
     let m
     try {
       m = JSON.parse(await readFile(path, 'utf8'))

package/src/view.mjs

@@ -0,0 +1,138 @@
+import { dayKey } from './days.mjs'
+
+// Drawing in the terminal: the site's blue heatmap in coloured squares, its
+// orange for work shipped with AI, plain characters where colour is off.
+
+const BLUES = ['#0d3a63', '#1a5fa3', '#2f81f7', '#79c0ff']
+const EMPTY = '#2a323d'
+const SHIP = '#f2994a'
+const MUTED = '#8b949e'
+
+// How much colour the terminal takes: none (NO_COLOR, piped output, a dumb
+// terminal), 256 colours, or full colour (COLORTERM says so; Windows Terminal).
+export function colorLevel(stream = process.stdout, env = process.env) {
+  if ('NO_COLOR' in env) return 0
+  if (env.FORCE_COLOR === '0') return 0
+  if (env.FORCE_COLOR) return env.FORCE_COLOR === '1' ? 2 : 3
+  if (!stream.isTTY || env.TERM === 'dumb') return 0
+  if (/truecolor|24bit/i.test(env.COLORTERM ?? '') || env.WT_SESSION) return 3
+  return 2
+}
+
+const rgb = hex => [1, 3, 5].map(i => parseInt(hex.slice(i, i + 2), 16))
+const to256 = ([r, g, b]) => 16 + 36 * Math.round((r / 255) * 5) + 6 * Math.round((g / 255) * 5) + Math.round((b / 255) * 5)
+
+export function painter(level = colorLevel()) {
+  const fg = hex => (level === 3 ? `\x1b[38;2;${rgb(hex).join(';')}m` : level === 2 ? `\x1b[38;5;${to256(rgb(hex))}m` : '')
+  const wrap = (open, text) => (level ? `${open}${text}\x1b[0m` : text)
+  return {
+    level,
+    color: (hex, text) => wrap(fg(hex), text),
+    bold: text => wrap('\x1b[1m', text),
+    dim: text => wrap(fg(MUTED), text),
+    ship: text => wrap(fg(SHIP), text),
+  }
+}
+
+// One day's cell: a coloured square by shade (with an orange dot after it
+// when something shipped with AI), or plain characters without colour.
+const PLAIN = ['░', '▒', '▓', '█']
+export function cell(p, shade, shipped) {
+  if (shade === null) return '  '
+  const mark = shipped ? (p.level ? p.ship('•') : '*') : ' '
+  if (p.level === 0) return (shade < 0 ? '·' : PLAIN[shade]) + mark
+  return p.color(shade < 0 ? EMPTY : BLUES[shade], '■') + mark
+}
+
+const value = d => (d ? (d.messages ?? 0) + (d.aiCommits ?? 0) * 20 : 0)
+const active = d => !!d && ((d.messages ?? 0) > 0 || (d.aiCommits ?? 0) > 0)
+
+// Shades by quartile of the person's own active days, as on the site.
+export function shader(days, from, to) {
+  const sorted = Object.entries(days)
+    .filter(([date, d]) => date >= from && date <= to && active(d))
+    .map(([, d]) => value(d))
+    .sort((a, b) => a - b)
+  const at = q => sorted[Math.floor(q * (sorted.length - 1))] ?? 0
+  const cuts = [at(0.25), at(0.5), at(0.75)]
+  return d => (!active(d) ? -1 : value(d) <= cuts[0] ? 0 : value(d) <= cuts[1] ? 1 : value(d) <= cuts[2] ? 2 : 3)
+}
+
+const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+const addDays = (key, n) => {
+  const [y, m, d] = key.split('-').map(Number)
+  return dayKey(new Date(y, m - 1, d + n))
+}
+const weekday = key => {
+  const [y, m, d] = key.split('-').map(Number)
+  return new Date(y, m - 1, d).getDay()
+}
+
+// The heatmap: Sunday-first columns from the first active day (or as many
+// weeks as fit), month names above, Mon/Wed/Fri down the side.
+export function heatmap(p, days, today, { columns = 80, first } = {}) {
+  const maxWeeks = Math.max(4, Math.floor((columns - 5) / 2))
+  const earliest = addDays(today, -(maxWeeks * 7 - 1) - weekday(today))
+  const from = first && first > earliest ? first : earliest
+  const start = addDays(from, -weekday(from))
+  const weeks = []
+  for (let day = start; day <= today; day = addDays(day, 7)) weeks.push(Array.from({ length: 7 }, (_, i) => addDays(day, i)))
+  const shade = shader(days, from, today)
+  // A month's name sits over its first week. When it would collide with the
+  // previous name, the previous one (a month shown for a week at most) gives way.
+  const labels = []
+  let lastMonth = -1
+  weeks.forEach((week, w) => {
+    const shown = week.find(d => d >= from) ?? week[0]
+    const month = Number(shown.slice(5, 7)) - 1
+    if (month !== lastMonth && w <= weeks.length - 2) {
+      const previous = labels.at(-1)
+      if (previous && w - previous.w < 2) labels.pop()
+      labels.push({ w, name: MONTHS[month] })
+    }
+    lastMonth = month
+  })
+  let header = '     '
+  for (const { w, name } of labels) if (header.length <= 5 + w * 2) header = header.padEnd(5 + w * 2) + name
+  const rows = ['', 'Mon', '', 'Wed', '', 'Fri', ''].map((label, d) => {
+    const cells = weeks.map(week => {
+      const date = week[d]
+      if (date < from || date > today) return '  '
+      const day = days[date]
+      return cell(p, shade(day), (day?.aiCommits ?? 0) > 0)
+    })
+    return `${p.dim(label.padEnd(4))} ${cells.join('')}`
+  })
+  const legend = `     ${p.dim('less')} ${[-1, 0, 1, 2, 3].map(s => cell(p, s, false)).join('')}${p.dim('more')}   ${p.level ? p.ship('•') : '*'} ${p.dim('shipped with AI')}`
+  return [p.dim(header), ...rows, legend].join('\n')
+}
+
+// The last four weeks in one line, from a board row's 12-week strip.
+export function recent(p, strip, length = 28) {
+  return strip
+    .flat()
+    .filter(s => s !== -2)
+    .slice(-length)
+    .map(s => cell(p, s, false).trimEnd() || ' ')
+    .join('')
+}
+
+export const compact = n =>
+  n >= 1e12 ? `${(n / 1e12).toFixed(1)}T` : n >= 1e9 ? `${(n / 1e9).toFixed(1)}B` : n >= 1e6 ? `${(n / 1e6).toFixed(1)}M` : n >= 1e4 ? `${(n / 1e3).toFixed(1)}K` : n.toLocaleString('en-US')
+
+export const TOOL_NAMES = {
+  claude: 'Claude Code',
+  codex: 'Codex',
+  cursor: 'Cursor',
+  copilot: 'Copilot',
+  gemini: 'Gemini CLI',
+  antigravity: 'Antigravity',
+  opencode: 'OpenCode',
+}
+
+// Pads text that may hold colour codes to a visible width.
+export const visible = text => text.replace(/\x1b\[[0-9;]*m/g, '')
+export const pad = (text, width, right = false) => {
+  const gap = ' '.repeat(Math.max(0, width - [...visible(text)].length))
+  return right ? gap + text : text + gap
+}

package/src/views.mjs

@@ -0,0 +1,130 @@
+import { compact, heatmap, pad, painter, recent, TOOL_NAMES } from './view.mjs'
+
+// The read-only commands: your profile and others', the board, today, and
+// the dashboard plain `vibestreak` shows. Each fetches the public API (with
+// the machine's token where it has one, so a hidden profile's owner still
+// sees it) and draws for the terminal's width.
+
+const fmt = n => Number(n ?? 0).toLocaleString('en-US')
+const plural = (n, one, many = `${one}s`) => `${fmt(n)} ${n === 1 ? one : many}`
+const toolList = tools => (tools ?? []).map(t => TOOL_NAMES[t] ?? t).join(', ')
+
+const PERIODS = ['today', '7d', '30d', '90d', 'all']
+const METRICS = ['consistency', 'shipped', 'streak', 'tokens']
+const TOOLS = Object.keys(TOOL_NAMES)
+
+async function getJson(server, path, token) {
+  const response = await fetch(new URL(path, server), { headers: token ? { authorization: `Bearer ${token}` } : {} })
+  const body = await response.json().catch(() => ({}))
+  if (response.status === 404) throw new Error('No such public profile.')
+  if (!response.ok) throw new Error(body.error ?? `${response.status} ${response.statusText}`)
+  return body
+}
+
+function streakLine(p, profile) {
+  const s = profile.summary.streak
+  const today = profile.activeToday ? p.color('#3fb950', '✓ active today') : s.current > 0 ? p.ship('streak ends at midnight') : p.dim('no live streak')
+  const level = profile.level ? `${p.color('#2f81f7', '◆')} ${profile.level}` : ''
+  const next = profile.next ? p.dim(` · ${plural(profile.next.remaining, 'day')} to ${profile.next.name}`) : ''
+  return `${p.bold(`${fmt(s.current)}-day streak`)} ${p.dim(`(best ${fmt(s.longest)})`)}  ${today}  ${level}${next}`
+}
+
+// `vibestreak me` and `vibestreak profile <handle>`.
+export async function profileView({ server, token, handle, columns }) {
+  const p = painter()
+  const profile = await getJson(server, `/api/v1/users/${encodeURIComponent(handle)}.json`, token)
+  const s = profile.summary
+  const out = [
+    `${p.bold(`@${profile.handle}`)}  ${p.dim(toolList(profile.tools))}`,
+    streakLine(p, profile),
+    '',
+    heatmap(p, profile.days, profile.today, { columns, first: s.first }),
+    '',
+    `${p.bold(fmt(s.activeDays))} active days${s.first ? p.dim(` since ${s.first}`) : ''}   ${p.ship(fmt(s.aiCommits))} commits shipped with AI ${p.dim(`on ${fmt(s.shippedDays)} days`)}`,
+    `${fmt(s.messages)} messages · ${fmt(s.toolCalls)} tool calls · ${compact(s.input + s.output + s.cacheRead + s.cacheWrite)} tokens${s.busiest ? p.dim(`   busiest day ${s.busiest.date}, ${fmt(s.busiest.messages)} messages`) : ''}`,
+    p.dim(profile.profileUrl),
+  ]
+  console.log(out.join('\n'))
+}
+
+// Board options from words or flags: `board 7d shipped claude`, `--from … --to …`.
+export function boardQuery(words, values) {
+  const params = new URLSearchParams()
+  for (const word of words.map(w => w.toLowerCase())) {
+    if (PERIODS.includes(word)) params.set('period', word)
+    else if (METRICS.includes(word)) params.set('metric', word)
+    else if (TOOLS.includes(word)) params.set('tool', word)
+    else throw new Error(`"${word}" is not a period (${PERIODS.join(', ')}), a ranking (${METRICS.join(', ')}) or a tool (${TOOLS.join(', ')}).`)
+  }
+  if (values.from || values.to) {
+    if (!values.from || !values.to) throw new Error('A custom range needs both --from and --to (YYYY-MM-DD).')
+    params.set('from', values.from)
+    params.set('to', values.to)
+    params.delete('period')
+  }
+  return params
+}
+
+const METRIC_LABEL = { consistency: 'active days', shipped: 'commits shipped with AI', streak: 'current streak', tokens: 'tokens' }
+
+// `vibestreak board`: the top ten, a four-week strip per person, and your
+// own row pinned below when you rank lower.
+export async function boardView({ server, words, values, you, columns }) {
+  const p = painter()
+  const params = boardQuery(words, values)
+  params.set('limit', String(values.limit ?? 10))
+  if (you) params.set('you', you)
+  const b = await getJson(server, `/api/v1/board?${params}`)
+  const period = b.range ? `${b.range.from} → ${b.range.to}` : { today: 'today', all: 'all time' }[b.period] ?? `last ${b.period}`
+  console.log(`${p.bold('Leaderboard')} ${p.dim(`· ${METRIC_LABEL[b.metric]} · ${period}${b.tool ? ` · ${TOOL_NAMES[b.tool]}` : ''} · ${plural(b.total, 'developer')}`)}`)
+  if (!b.rows.length) return console.log(p.dim('Nobody here yet for these days.'))
+  const wide = columns >= 96
+  const handleWidth = Math.min(22, Math.max(8, ...b.rows.map(r => r.handle.length + 1)))
+  const header = [pad('#', 4), pad('developer', handleWidth + 1), wide ? pad('last 4 weeks', 29) : '', pad('active', 7, true), pad('streak', 8, true), pad('shipped', 9, true), pad('tokens', 8, true)].join(' ')
+  console.log(p.dim(header))
+  const line = r => {
+    const me = you && r.handle.toLowerCase() === you.toLowerCase()
+    const name = pad(`@${r.handle}`, handleWidth + 1)
+    return [
+      pad(String(r.rank), 4),
+      me ? p.bold(name) : name,
+      wide ? pad(recent(p, r.strip), 29) : '',
+      pad(fmt(r.activeDays), 7, true),
+      pad(`${fmt(r.streak)}d`, 8, true),
+      pad(p.ship(fmt(r.aiCommits)), 9, true),
+      pad(compact(r.tokens), 8, true),
+    ].join(' ') + (me ? p.dim('  ← you') : '')
+  }
+  for (const r of b.rows) console.log(line(r))
+  if (b.you && b.you.rank > b.rows.length) console.log(`${p.dim('  …')}\n${line(b.you)}`)
+  console.log(p.dim(`\nMore: vibestreak board [today|7d|30d|90d|all] [consistency|shipped|streak|tokens] [tool]   ·   ${new URL('/', server)}`))
+}
+
+// `vibestreak today`: who is coding with AI today, and whose streak ends at midnight.
+export async function todayView({ server }) {
+  const p = painter()
+  const t = await getJson(server, '/api/v1/today')
+  console.log(`${p.color('#3fb950', '●')} ${p.bold(plural(t.active.length, 'developer'))} coding with AI today ${p.dim(`(of ${fmt(t.developers)})`)}`)
+  for (const r of t.active.slice(0, 15)) console.log(`  @${pad(r.handle, 22)} ${pad(`${fmt(r.streak)}d`, 6, true)}  ${p.dim(toolList(r.tools))}`)
+  if (t.atRisk.length) {
+    console.log(`\n${p.ship(`${plural(t.atRisk.length, 'streak')} at risk`)} ${p.dim('· ends at their midnight')}`)
+    for (const r of t.atRisk.slice(0, 10)) console.log(`  @${pad(r.handle, 22)} ${pad(p.ship(`${fmt(r.streak)}d`), 6, true)}`)
+  }
+}
+
+// Plain `vibestreak`: your streak, the last twelve weeks, your rank, and
+// what to run next.
+export async function dashboardView({ server, token, handle, columns }) {
+  const p = painter()
+  const [profile, b] = await Promise.all([
+    getJson(server, `/api/v1/users/${encodeURIComponent(handle)}.json`, token),
+    getJson(server, `/api/v1/board?limit=0&you=${encodeURIComponent(handle)}`).catch(() => null),
+  ])
+  const rank = b?.you ? `#${b.you.rank} of ${fmt(b.total)} ${p.dim('· 30 days, consistency')}` : p.dim('not on the public board')
+  console.log(`${p.bold(`@${profile.handle}`)}  ${rank}`)
+  console.log(streakLine(p, profile))
+  console.log('')
+  console.log(heatmap(p, profile.days, profile.today, { columns: Math.min(columns, 31), first: profile.summary.first }))
+  console.log('')
+  console.log(p.dim('vibestreak me · board · today · status · help'))
+}