clauddy 1.11.0 → 1.12.0

package/README.md

@@ -9,7 +9,7 @@ A cute pixel-art desktop pet for macOS that tracks your Claude Code usage — mi
 
 ## What it shows
 
-- **Current session** — real % used + **"resets in Xh Ym"** + session tokens
+- **Current session** — real % used + **"resets in Xh Ym"** + session tokens, and a projection of where that pace is taking you (see [Burn rate](#burn-rate))
 - **Weekly · all models** — real % used + tokens over the last 7 days
 - **Status line** under the pet: `● working · 1.6M tok/min` (or today's tokens when idle)
 - **By model · 7 days** — Opus / Sonnet / Haiku / Fable, in tokens
@@ -26,6 +26,19 @@ The session/weekly **%** comes straight from your Anthropic account, so it match
 
 The token is saved locally (see [Data & privacy](#data--privacy)) and refreshed automatically. **Until you connect**, the limits area shows a _"Connect your account"_ prompt instead of percentages.
 
+## Burn rate
+
+Knowing you're at **82%** with **1h 12m** left on the window still leaves you doing arithmetic in your head. So Clauddy does it for you: it fits the slope of your recent usage and projects when you'd hit 100% — showing one extra line under the session bar:
+
+- **`~35m left at this pace`** (in coral) — you'd run out before the window resets. Ease off, or wrap up.
+- **`resets before you run out`** — the reset gets there first. Carry on.
+
+The slope is fitted over your **session tokens** rather than the account %. The % is the number you care about, but it arrives as a whole number every ~5 minutes — over a short window the whole signal is a single `16 → 17` step, which throws the fitted pace off by multiples. Local-log tokens step too — one jump per assistant turn — but in increments some 10–20× finer, so the slope is far steadier; the account % then anchors it, converting tokens into % and re-calibrating on every poll.
+
+It reads your **recent** pace, not the session average: go quiet for a few minutes and the projection eases off, which is the point.
+
+It only appears once there's enough to say honestly — roughly 5 minutes into a session — and stays hidden while you're idle, when the pace is flat, or right after a reset. A projection is a projection: change your pace and it changes with you.
+
 ## The pet's states
 
 <table>
@@ -109,9 +122,7 @@ The quickest path works the same as macOS — with [Bun](https://bun.sh) or Node
 bunx clauddy   # or: npx clauddy
 ```
 
-Prefer a standalone app with no Node/Bun? Grab the **portable zip** (`Clauddy-<version>-win.zip`) from the [latest release](https://github.com/renatoaug/claude-usage-monitor/releases), unzip it anywhere, and run `Clauddy.exe`. Because the app is unsigned, Windows **SmartScreen** shows a "Windows protected your PC" prompt the first time — click **More info → Run anyway**. From then on it starts with Windows.
-
-> Windows builds are produced by the **Build** workflow (Actions ▸ Build) — attaching them to every release automatically is on the roadmap.
+Prefer a standalone app with no Node/Bun? Grab the **portable zip** (`Clauddy-<version>-win-x64.zip`) from the [latest release](https://github.com/renatoaug/claude-usage-monitor/releases), unzip it anywhere, and run `Clauddy.exe`. Because the app is unsigned, Windows **SmartScreen** shows a "Windows protected your PC" prompt the first time — click **More info → Run anyway**. From then on it starts with Windows.
 
 ### Linux (x64)
 
@@ -121,15 +132,13 @@ The quickest path works the same as macOS — with [Bun](https://bun.sh) or Node
 bunx clauddy   # or: npx clauddy
 ```
 
-Prefer a standalone app? Grab the **AppImage** or **tar.gz** (`Clauddy-<version>.AppImage` / `clauddy-<version>.tar.gz`) from the [latest release](https://github.com/renatoaug/claude-usage-monitor/releases), then:
+Prefer a standalone app? Grab the **AppImage** or **tar.gz** (`Clauddy-<version>-linux-x64.AppImage` / `Clauddy-<version>-linux-x64.tar.gz`) from the [latest release](https://github.com/renatoaug/claude-usage-monitor/releases), then:
 
 ```bash
 chmod +x Clauddy-*.AppImage
 ./Clauddy-*.AppImage
 ```
 
-> Linux builds are produced by the **Build** workflow (Actions ▸ Build) — attaching them to every release automatically is on the roadmap.
-
 > The system tray icon needs an indicator extension on vanilla GNOME (e.g. "AppIndicator and KStatusNotifier Item Support") — it works out of the box on Cinnamon, KDE, and XFCE. Autostart-at-login is wired up via an XDG `.desktop` entry in `~/.config/autostart/`.
 
 > The app keeps its data in `~/.claude-usage-monitor`, regardless of platform or how you run it.
@@ -218,9 +227,15 @@ Nothing leaves your machine except the OAuth calls to Anthropic's own login and
 Releases are **fully automated**. Every push to `main` runs
 [semantic-release](https://semantic-release.gitbook.io) (`.github/workflows/release.yml`):
 it reads the **Conventional Commits** and, when there's something to ship,
-computes the version, builds the macOS app, publishes `clauddy` to npm, and
-cuts a GitHub Release with the `.app` zip. Nothing to do by hand — just merge
-your PRs.
+computes the version, builds the app for **macOS, Windows and Linux** on their
+own runners, publishes `clauddy` to npm, and cuts a GitHub Release with every
+artifact attached. Nothing to do by hand — just merge your PRs.
+
+The pipeline runs in three stages, because electron-builder can't cross-build
+Windows/Linux from macOS: `version` (a semantic-release dry-run that computes
+the next version) → `build` (a matrix that stamps that version into
+`package.json` so the filenames are right) → `publish` (downloads every
+artifact and runs semantic-release for real).
 
 - `feat:` → minor, `fix:` → patch, `feat!:`/`BREAKING CHANGE` → major.
 - `docs:`/`chore:`/`ci:` etc. don't trigger a release.

package/main.js

@@ -36,6 +36,9 @@ if (process.env.CLAUDE_CONFIG_DIR) {
 const EXTERNAL_CONFIG = path.join(DATA_DIR, 'config.json')
 // debug channel: `./pet <state>` writes here to force a state (dev only)
 const DEBUG_FILE = path.join(DATA_DIR, 'debug.json')
+// remembered floating-widget position: survives restarts and lets the widget
+// return to the monitor the user parked it on after a display is unplugged/replugged
+const WINDOW_STATE = path.join(DATA_DIR, 'window.json')
 
 let win
 let pollTimer
@@ -49,6 +52,8 @@ let currentMode = 'floating' // 'floating' widget | 'menubar' popover
 let trayBounds = null // last known tray icon rect, to anchor the popover
 let lastBlurHide = 0 // debounce: ignore the tray click that dismissed the popover
 let sessionPct = null // authoritative session % shown in the tray title
+let lastProgrammaticMove = 0 // ignore the 'moved' event our own setPosition triggers
+let displayChanging = 0 // ignore OS window-shuffles while a display (dis)connects
 
 function publicConfig(c) {
   return {
@@ -151,6 +156,27 @@ function createWindow() {
     }
   })
 
+  // remember where the user parks the widget — but not the moves we make
+  // ourselves (resize re-anchoring) nor the ones the OS forces when a display
+  // (dis)connects, so a monitor going dark never overwrites the saved spot
+  win.on('moved', () => {
+    if (Date.now() - lastProgrammaticMove < 500) return
+    if (Date.now() - displayChanging < 2000) return
+    saveWindowState()
+  })
+
+  // when a monitor is unplugged/replugged (or its layout changes), put the
+  // floating widget back on the display the user parked it on — the OS dumps
+  // it on the primary display otherwise, and never moves it back on its own
+  const onDisplayChange = () => {
+    displayChanging = Date.now()
+    if (currentMode === 'floating' && win && !win.isDestroyed() && win.isVisible())
+      positionFloating()
+  }
+  screen.on('display-added', onDisplayChange)
+  screen.on('display-removed', onDisplayChange)
+  screen.on('display-metrics-changed', onDisplayChange)
+
   const tick = () => {
     if (!win || win.isDestroyed()) return
     try {
@@ -250,6 +276,43 @@ function showPopover() {
   win.focus()
 }
 
+// route every programmatic move through here so the 'moved' handler can tell
+// our own repositioning apart from a genuine user drag (and skip saving it)
+function moveWindow(x, y) {
+  lastProgrammaticMove = Date.now()
+  win.setPosition(Math.round(x), Math.round(y))
+}
+
+// persist the widget's anchor — its bottom-right corner, since the window's
+// size changes as the pet animates — so it can be restored later
+function saveWindowState() {
+  if (currentMode !== 'floating' || !win || win.isDestroyed()) return
+  const b = win.getBounds()
+  try {
+    fs.mkdirSync(DATA_DIR, { recursive: true })
+    fs.writeFileSync(WINDOW_STATE, JSON.stringify({ right: b.x + b.width, bottom: b.y + b.height }))
+  } catch {}
+}
+
+function loadWindowState() {
+  try {
+    const s = JSON.parse(fs.readFileSync(WINDOW_STATE, 'utf8'))
+    return Number.isFinite(s?.right) && Number.isFinite(s?.bottom) ? s : null
+  } catch {
+    return null
+  }
+}
+
+// is the saved bottom-right corner on a display that's currently connected?
+function cornerVisible(right, bottom) {
+  const x = Math.round(right - 1)
+  const y = Math.round(bottom - 1)
+  return screen.getAllDisplays().some((d) => {
+    const b = d.bounds
+    return x >= b.x && x < b.x + b.width && y >= b.y && y < b.y + b.height
+  })
+}
+
 // center the popover under the tray icon, kept on-screen
 function positionUnderTray() {
   const b = win.getBounds()
@@ -261,13 +324,20 @@ function positionUnderTray() {
     y = Math.round(trayBounds.y + trayBounds.height)
   }
   x = Math.max(8, Math.min(x, workAreaSize.width - b.width - 8))
-  win.setPosition(x, y)
+  moveWindow(x, y)
 }
 
 function positionFloating() {
-  const { workAreaSize } = screen.getPrimaryDisplay()
   const b = win.getBounds()
-  win.setPosition(workAreaSize.width - b.width - 24, workAreaSize.height - b.height - 24)
+  // reuse the saved spot when that monitor is still connected; otherwise fall
+  // back to the primary display's bottom-right corner
+  const saved = loadWindowState()
+  if (saved && cornerVisible(saved.right, saved.bottom)) {
+    moveWindow(saved.right - b.width, saved.bottom - b.height)
+    return
+  }
+  const { workAreaSize } = screen.getPrimaryDisplay()
+  moveWindow(workAreaSize.width - b.width - 24, workAreaSize.height - b.height - 24)
 }
 
 // the tray shows the live session % (macOS title), turning 🔥 near the limit
@@ -296,12 +366,20 @@ ipcMain.on('resize', (_e, w, h) => {
   if (!win || win.isDestroyed()) return
   const width = Math.max(100, Math.round(w))
   const height = Math.max(110, Math.round(h))
-  win.setContentSize(width, height)
   if (currentMode === 'menubar') {
+    win.setContentSize(width, height)
     if (win.isVisible()) positionUnderTray() // keep it anchored under the tray
   } else {
-    const { workAreaSize } = screen.getPrimaryDisplay()
-    win.setPosition(workAreaSize.width - width - 24, workAreaSize.height - height - 24)
+    // keep the widget pinned to its current bottom-right corner on whatever
+    // display the user dragged it to. setContentSize grows from the top-left
+    // origin, so re-anchor by the old corner instead of snapping to the primary
+    // display's bottom-right (which yanked the widget back on every update).
+    const before = win.getBounds()
+    const right = before.x + before.width
+    const bottom = before.y + before.height
+    win.setContentSize(width, height)
+    const after = win.getBounds()
+    moveWindow(right - after.width, bottom - after.height)
   }
 })
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "clauddy",
   "desktopName": "clauddy.desktop",
-  "version": "1.11.0",
+  "version": "1.12.0",
   "description": "A cute desktop pet that tracks your Claude Code usage",
   "main": "main.js",
   "bin": {
@@ -80,17 +80,20 @@
       "category": "public.app-category.developer-tools",
       "target": "dir",
       "identity": null,
-      "icon": "build/icon.icns"
+      "icon": "build/icon.icns",
+      "artifactName": "${productName}-${version}-mac-${arch}.${ext}"
     },
     "win": {
       "target": "zip",
-      "icon": "build/icon.ico"
+      "icon": "build/icon.ico",
+      "artifactName": "${productName}-${version}-win-${arch}.${ext}"
     },
     "linux": {
       "target": [
         "tar.gz",
         "AppImage"
       ],
+      "artifactName": "${productName}-${version}-linux-${arch}.${ext}",
       "category": "Utility",
       "icon": "build/icon.png",
       "syncDesktopName": true
@@ -101,7 +104,6 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.5.0",
-    "@semantic-release/exec": "^7.1.0",
     "electron-builder": "^26.15.3",
     "semantic-release": "^25.0.5"
   }

package/renderer/index.html

@@ -246,6 +246,7 @@
               <div class="meter-top"><span>current session</span><span id="session-pct">0%</span></div>
               <div class="track"><div class="fill" id="session-fill"></div></div>
               <div class="sub" id="session-sub">no active session</div>
+              <div class="sub proj" id="session-proj" hidden></div>
             </div>
             <div class="meter">
               <div class="meter-top"><span>weekly · all models</span><span id="week-pct">0%</span></div>

package/renderer/pet.js

@@ -154,6 +154,80 @@ function fmtReset(ms) {
   const m = Math.floor((ms % 3600000) / 60000)
   return h > 0 ? `${h}h ${m}m` : `${m}m`
 }
+// ---- burn-rate projection ----
+// The panel knows where you are (82%) and when the window resets (1h 12m); it
+// can also say where you're headed — fit a slope through recent usage and
+// project the crossing of 100%. If the reset lands first there's nothing to
+// worry about, which is worth saying out loud rather than leaving blank.
+//
+// The slope is fitted over session *tokens*, not the account %. The % is the
+// number we ultimately care about, but it arrives as a whole number every ~5
+// min: over a short window the whole signal is a single 16 → 17 step, which
+// makes the fitted pace wrong by multiples. Local-log tokens step too — one
+// jump per assistant turn, with plateaus in between — but in increments some
+// 10-20x finer, so they carry a far steadier slope. The
+// account % still anchors it: pct/tokens converts tokens/ms into %/ms and
+// re-calibrates on every poll, so the projection stays tied to the real number.
+const PROJ_WINDOW_MS = 45 * 60 * 1000 // only fit recent samples — pace changes
+const PROJ_MIN_SAMPLES = 4
+const PROJ_MIN_SPAN_MS = 5 * 60 * 1000 // shorter than a % fit affords, and steadier
+const PROJ_SAMPLE_EVERY_MS = 30 * 1000 // usage polls every few seconds; thin it out
+let tokTrail = []
+
+function noteTokens(tokens, active) {
+  if (!active || !(tokens > 0)) {
+    tokTrail = [] // no session, no trend
+    return
+  }
+  // session tokens only climb within a window — a drop means it rolled over,
+  // and the fresh sample starts the new trail rather than being throttled away
+  let last = tokTrail[tokTrail.length - 1]
+  if (last && tokens < last.tokens) {
+    tokTrail = []
+    last = undefined
+  }
+  const now = Date.now()
+  if (last && now - last.t < PROJ_SAMPLE_EVERY_MS) return
+  tokTrail.push({ t: now, tokens })
+  tokTrail = tokTrail.filter((s) => s.t >= now - PROJ_WINDOW_MS)
+}
+
+// least-squares slope in tokens per ms, or null when there isn't enough to say
+function burnSlope() {
+  if (tokTrail.length < PROJ_MIN_SAMPLES) return null
+  const span = tokTrail[tokTrail.length - 1].t - tokTrail[0].t
+  if (span < PROJ_MIN_SPAN_MS) return null
+  const n = tokTrail.length
+  const t0 = tokTrail[0].t
+  let sx = 0
+  let sy = 0
+  let sxy = 0
+  let sxx = 0
+  for (const s of tokTrail) {
+    const x = s.t - t0
+    sx += x
+    sy += s.tokens
+    sxy += x * s.tokens
+    sxx += x * x
+  }
+  const denom = n * sxx - sx * sx
+  if (denom === 0) return null
+  return (n * sxy - sx * sy) / denom
+}
+
+// → { kind: 'eta', ms } when you'd run out first, { kind: 'safe' } when the
+// reset beats you there, or null when we can't tell yet.
+function project(pct, resetMs, tokens) {
+  if (!(pct > 0) || !(tokens > 0)) return null // no anchor to convert tokens → %
+  const tokPerMs = burnSlope()
+  if (tokPerMs == null || tokPerMs <= 0) return null // idle or flat
+  const pctPerMs = tokPerMs * (pct / tokens)
+  const eta = (100 - pct) / pctPerMs
+  if (!Number.isFinite(eta) || eta <= 0) return null
+  if (resetMs != null && eta >= resetMs) return { kind: 'safe' }
+  return { kind: 'eta', ms: eta }
+}
+
 function setState(name) {
   const b = document.body
   ;[...b.classList].forEach((c) => {
@@ -500,6 +574,17 @@ function render(d) {
     ? `resets in ${fmtReset(sessReset)} · ${fmtTokens(d.session.tokens)} tokens`
     : 'no active session'
 
+  // where this pace is taking you — hidden until there's enough trail to tell
+  noteTokens(d.session.tokens, sessActive)
+  const proj = sessActive && sessPct < 100 ? project(sessPct, sessReset, d.session.tokens) : null
+  const pe = el('session-proj')
+  pe.hidden = !proj
+  pe.classList.toggle('tight', proj?.kind === 'eta')
+  if (proj) {
+    pe.textContent =
+      proj.kind === 'eta' ? `~${fmtReset(proj.ms)} left at this pace` : 'resets before you run out'
+  }
+
   el('week-pct').textContent = `${Math.round(wkPct)}%`
   const wf = el('week-fill')
   wf.style.width = `${wkPct}%`

package/renderer/style.css

@@ -1618,6 +1618,18 @@ body.state-tired #status-text {
   letter-spacing: 0.2px;
 }
 
+/* burn-rate projection — calm by default, warm when you'd run out first */
+.sub.proj {
+  margin-top: 2px;
+  font-style: italic;
+  opacity: 0.85;
+}
+.sub.proj.tight {
+  color: var(--coral);
+  font-style: normal;
+  opacity: 1;
+}
+
 /* 30-day map */
 #heat {
   margin-top: 12px;