clauddy 1.11.1 → 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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "clauddy",
   "desktopName": "clauddy.desktop",
-  "version": "1.11.1",
+  "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;