vibestreak 0.1.0 → 0.1.2

package/bin/vibestreak.mjs

@@ -2,8 +2,8 @@
 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 { 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 { CONFIG_PATH, loadConfig, saveConfig } from '../src/config.mjs'
 import { DEFAULT_ROOTS, globalEmail, scanEmails } from '../src/git.mjs'
@@ -21,9 +21,11 @@ const HELP = `${BRAND} — share your AI coding heatmap: what you shipped, and h
                                      the addresses you commit as (all of your accounts)
   ${BRAND} roots [add <dir>|remove <dir>]
                                      where to look for git repos
+  ${BRAND} status                    profile, last sync, streak, autosync and nudge
   ${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)
+                                     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,
@@ -116,20 +118,34 @@ async function main() {
 
   if (command === 'collect' || command === 'sync') return sync(config, values, log, command === 'sync')
 
+  if (command === 'status') return status(config)
+
   if (command === 'nudge') {
     const bin = fileURLToPath(import.meta.url)
-    if (rest[0] === 'on' || rest[0] === 'off') {
-      config.nudge = rest[0] === 'on'
+    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 (rest[0] === 'test') {
+    if (action === '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.
+    // `nudge run`, the evening job: 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))
@@ -146,7 +162,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(
@@ -181,6 +197,7 @@ 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.lastSyncSummary = { days: result.days, commits: result.commits, repos: s.repos }
   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)'}` : ''
@@ -188,6 +205,61 @@ async function sync(config, values, log, isSync) {
   return result
 }
 
+const ago = iso => {
+  if (!iso) return 'never'
+  const minutes = Math.round((Date.now() - Date.parse(iso)) / 60000)
+  return minutes < 1 ? 'just now' : minutes < 60 ? `${minutes} min ago` : minutes < 48 * 60 ? `${Math.round(minutes / 60)} h ago` : `${Math.round(minutes / 1440)} days ago`
+}
+const at = ({ at, day }) => `${day} ${clock([at.getHours(), at.getMinutes()])}`
+
+// The server's view of the streak, or why it can't be had (not linked, offline).
+async function serverStatus(config) {
+  if (!config.server || !config.token) return { error: `not linked: run \`${BRAND} login --token PASTE_YOUR_TOKEN\`` }
+  try {
+    return await api(config, '/api/v1/me')
+  } catch (error) {
+    return { error: error.message }
+  }
+}
+
+function streakLine(streak) {
+  if (!streak) return 'unknown'
+  const today = streak.activeToday ? 'active today' : streak.current > 0 ? 'not yet today: ends at midnight' : 'no live streak'
+  const next = streak.next ? ` · ${streak.next.remaining} ${streak.next.remaining === 1 ? 'day' : 'days'} to ${streak.next.name}` : ''
+  return `${streak.current} ${streak.current === 1 ? 'day' : 'days'} · ${today}${next}`
+}
+
+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\`)` : ''
+  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 ${time} unless you code with AI first`) : 'no nudge: no live streak'
+  console.log(`Streak      ${streakLine(s)}`)
+  console.log(`Tonight     ${tonight}`)
+}
+
+async function status(config) {
+  const [scheduled, me] = await Promise.all([autosyncStatus(), serverStatus(config)])
+  const row = (label, value) => console.log(`${label.padEnd(11)} ${value}`)
+  row('Profile', me.error ? me.error : `@${me.handle} · ${me.profileUrl}`)
+  if (!me.error && me.github?.length) row('GitHub', me.github.map(g => `github.com/${g}`).join(', '))
+  row('Machine', config.machineName)
+  const last = config.lastSyncSummary
+  row('Last sync', config.lastSync ? `${ago(config.lastSync)}${last ? ` · ${last.days} days, ${last.commits} commits from ${last.repos} repos` : ''}` : `never: run \`${BRAND} sync\``)
+  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(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)
+}
+
 main().catch(error => {
   console.error(`${BRAND}: ${error.message}`)
   process.exitCode = 1

package/package.json

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

@@ -1,10 +1,12 @@
 import { execFile } from 'node:child_process'
+import { existsSync } from 'node:fs'
 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'
+import { NUDGE_DEFAULT } from './nudge.mjs'
 
 const run = promisify(execFile)
 
@@ -15,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', '--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
@@ -64,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) {
@@ -78,6 +81,10 @@ const launchd = {
     }
     return 'launchd'
   },
+  async status() {
+    const has = name => existsSync(join(agents(), `${LAUNCHD[name]}.plist`))
+    return { on: has('sync'), using: 'launchd', nudge: has('nudge') }
+  },
   async remove() {
     for (const label of Object.values(LAUNCHD)) {
       const plist = join(agents(), `${label}.plist`)
@@ -124,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')
@@ -148,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(() => {})
@@ -167,9 +174,17 @@ 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() {
+    if (existsSync(join(units(), 'vibestreak-sync.timer'))) {
+      return { on: true, using: 'systemd', nudge: existsSync(join(units(), 'vibestreak-nudge.timer')) }
+    }
+    const cron = await run('crontab', ['-l']).then(r => r.stdout, () => '')
+    const block = cron.match(new RegExp(`${CRON_BEGIN}[\\s\\S]*?${CRON_END}`))?.[0] ?? ''
+    return { on: /\bsync\b/.test(block), using: 'crontab', nudge: /\bnudge\b/.test(block) }
+  },
   async remove() {
     for (const name of ['vibestreak-sync', 'vibestreak-nudge']) {
       await run('systemctl', ['--user', 'disable', '--now', `${name}.timer`]).catch(() => {})
@@ -189,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) {
@@ -204,8 +224,12 @@ const windows = {
     }
     return 'Task Scheduler'
   },
+  async status() {
+    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(() => {})
   },
 }
 
@@ -213,18 +237,33 @@ 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() }
 }
 
+// What the system's scheduler holds now: whether the syncs and the nudge are scheduled.
+export async function autosyncStatus() {
+  const scheduler = SCHEDULERS[platform()]
+  return scheduler ? scheduler.status() : { on: false, using: undefined, nudge: false }
+}
+
+// The next of the given daily times after `now`: today if one is still ahead, else tomorrow's first.
+export function nextRun(times, now = new Date()) {
+  const today = times.map(([h, m]) => new Date(now.getFullYear(), now.getMonth(), now.getDate(), h, m)).sort((a, b) => a - b)
+  const later = today.find(t => t > now)
+  if (later) return { at: later, day: 'today' }
+  const [first] = today
+  return { at: new Date(first.getFullYear(), first.getMonth(), first.getDate() + 1, first.getHours(), first.getMinutes()), day: 'tomorrow' }
+}
+
 export async function removeAutosync() {
   await SCHEDULERS[platform()]?.remove()
   return { removed: true }

package/src/nudge.mjs

@@ -11,6 +11,56 @@ export function shouldNudge(streak, config) {
   return streak.atRisk === true && streak.current > 0 && config.lastNudge !== streak.today
 }
 
+// What `nudge` was asked to do. Alone it shows the nudge's status; with
+// --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', '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}.` : ''