vibestreak 0.1.2 → 0.2.0

package/bin/vibestreak.mjs

@@ -4,15 +4,23 @@ import { parseArgs } from 'node:util'
 
 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 } from '../src/collect.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)
@@ -58,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
@@ -186,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)`)
@@ -197,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)'}` : ''

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibestreak",
-  "version": "0.1.2",
+  "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/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/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'))
+}