clauddy 1.0.0

package/README.md

@@ -0,0 +1,154 @@
+# 🟫 Claude Usage Monitor
+
+A cute pixel-art desktop pet for macOS that tracks your Claude Code usage — mirroring the official **Settings → Usage** panel (current session + weekly limits, in tokens & %), with animations.
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/renatoaug/claude-usage-monitor/main/docs/media/overview.gif" width="300" alt="Claude Usage Monitor — the full widget showing session, weekly, by-model and 30-day usage" /><br />
+  <em>A little terracotta creature that lives in the corner of your screen, eats your tokens, and naps when you're idle.</em>
+</p>
+
+## What it shows
+
+- **Current session** — real % used + **"resets in Xh Ym"** + session tokens
+- **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
+- **30-day map** — colored squares by daily tokens (green = light → red = heavy), with the monthly total
+
+The **percentages are real**, pulled from your account (you log in once — see below). The token counts, by-model breakdown, activity status, and 30-day map come from your local logs (`~/.claude/projects/**/*.jsonl`). Everything is token-based — no dollars.
+
+## Account & live usage
+
+The session/weekly **%** comes straight from your Anthropic account, so it matches the official panel exactly. You connect once via a browser login:
+
+1. Open **⚙ Settings → "Log in with browser"** — your browser opens an Anthropic auth page.
+2. Log in, copy the **authentication code** shown, and paste it back into the app → **Connect**.
+
+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.
+
+## The pet's states
+
+<table>
+  <tr>
+    <td align="center"><img src="https://raw.githubusercontent.com/renatoaug/claude-usage-monitor/main/docs/media/idle.gif" width="280" alt="idle" /><br /><b>idle</b><br /><sub>breathes &amp; blinks</sub></td>
+    <td align="center"><img src="https://raw.githubusercontent.com/renatoaug/claude-usage-monitor/main/docs/media/working.gif" width="280" alt="working" /><br /><b>working</b><br /><sub>hops &amp; eats token coins</sub></td>
+  </tr>
+  <tr>
+    <td align="center"><img src="https://raw.githubusercontent.com/renatoaug/claude-usage-monitor/main/docs/media/on-fire.gif" width="280" alt="on fire" /><br /><b>on fire</b><br /><sub>session ≥ 90% → red, shivers, flames</sub></td>
+    <td align="center"><img src="https://raw.githubusercontent.com/renatoaug/claude-usage-monitor/main/docs/media/tired.gif" width="280" alt="maxed out" /><br /><b>maxed out</b><br /><sub>session at 100% → drained, slumped, sweating</sub></td>
+  </tr>
+  <tr>
+    <td align="center"><img src="https://raw.githubusercontent.com/renatoaug/claude-usage-monitor/main/docs/media/sleeping.gif" width="280" alt="sleeping" /><br /><b>sleeping</b><br /><sub>idle 5+ min → blue zzz &amp; moonlight</sub></td>
+    <td align="center"><img src="https://raw.githubusercontent.com/renatoaug/claude-usage-monitor/main/docs/media/poke.gif" width="280" alt="poke" /><br /><b>poke</b><br /><sub>click the pet → squish &amp; hearts</sub></td>
+  </tr>
+  <tr>
+    <td colspan="2" align="center"><img src="https://raw.githubusercontent.com/renatoaug/claude-usage-monitor/main/docs/media/celebrate.gif" width="280" alt="celebrate" /><br /><b>celebrate</b><br /><sub>session resets → jump &amp; confetti</sub></td>
+  </tr>
+</table>
+
+Plus a welcome **wave** on launch. You can preview any state from the terminal with [`./pet`](#simulate-states-pet).
+
+## Install
+
+macOS (Apple Silicon). Two ways, depending on what you want:
+
+### 1. Download the app — opens at login (recommended)
+
+For everyday use, grab the prebuilt app — no terminal, no setup:
+
+1. Download the latest **`Claude Usage Monitor-…-mac.zip`** from the [**Releases**](https://github.com/renatoaug/claude-usage-monitor/releases/latest) page.
+2. Unzip it and drag **Claude Usage Monitor.app** into `/Applications`.
+3. First open: right-click the app → **Open** → **Open** (it's unsigned).
+
+It registers itself in **Login Items**, so it **starts automatically** with your Mac — set it and forget it.
+
+### 2. Run it via `bunx` (no install)
+
+Needs [Bun](https://bun.sh) (or use `npx` with Node 24):
+
+```bash
+bunx clauddy
+```
+
+The first run downloads Electron, so give it a moment. Handy for a quick run, but it stays up **only while that command is open** and won't start on its own. Quit it with the **×** button.
+
+> The app keeps its data in `~/.claude-usage-monitor`, regardless of how you run it.
+
+## Controls
+
+- **Drag** the widget anywhere on screen
+- **–** minimizes to just the pet's face (showing the live session %); the **⤢** button or a double-click on the pet expands it back
+- **⚙** opens settings (log in, toggle alerts, set thresholds)
+- **↗** opens the official Usage page
+- **×** quits
+
+## Alerts
+
+Optional **macOS notifications** when your session or weekly usage crosses the thresholds you set (default **80%** and **95%**) — e.g. _"Your session is over 80% — now at 82%"_. They re-arm automatically once usage drops back below a threshold (after a reset). Toggle them and edit the thresholds in **⚙ Settings**.
+
+## Configure (`config.json`)
+
+Settings saved from the UI live in `~/.claude-usage-monitor/config.json`, so you can tweak them without rebuilding:
+
+```jsonc
+{
+  "alerts": true, // macOS notifications on/off
+  "alertThresholds": [80, 95], // notify when session/week cross these %
+  "pollIntervalMs": 4000, // how often local logs are re-read
+  "activeThresholdMs": 8000, // "working" if Claude was active within this window
+  "sleepThresholdMs": 300000, // "sleeping" after this much idle time (5 min)
+}
+```
+
+## Simulate states (`./pet`)
+
+While developing the animations, force any state from the terminal — the app watches `~/.claude-usage-monitor/debug.json` and reacts live (no rebuild needed). Run from the repo root:
+
+```bash
+./pet fire        # 🔥 on fire — flames, shivers, red tint
+./pet sleeping    # 😴 sleeping — blue zzz, closed eyes, moonlight
+./pet working     # 🍴 working — eats token coins and hops
+./pet idle        # 🙂 idle — breathe + blink
+
+./pet poke        # 💕 one-shot squish + hearts
+./pet celebrate   # 🎉 one-shot jump + confetti burst
+
+./pet auto        # ↩️ release control, back to real usage data
+```
+
+## How it works
+
+- **`main.js`** — Electron main process: frameless, transparent, always-on-top window; polls usage; fires macOS notifications; watches `config.json` and `debug.json`.
+- **`usage.js`** — reads `~/.claude/projects/**/*.jsonl`, sums tokens per model/day, detects the rolling 5-hour session window, and the working/sleeping activity status.
+- **`auth.js`** — OAuth login (PKCE, same public client as Claude Code) that fetches the authoritative usage %. Token stored locally, never committed.
+- **`renderer/`** — the pet itself: an SVG pixel sprite, CSS animations, and the Web Animations API for particles.
+- **`make-icon.js`** — generates the app icon from the pixel sprite (`build/icon.icns`).
+
+## Data & privacy
+
+Everything lives on your machine, in `~/.claude-usage-monitor/`:
+
+- `auth.json` — your OAuth token (file mode `600`, never committed)
+- `config.json` — your alert settings
+- `debug.json` — scratch file for the `./pet` simulator
+
+Nothing leaves your machine except the OAuth calls to Anthropic's own login and usage endpoints.
+
+## Dev tooling
+
+- **Bun** for install/scripts, **Node 24** pinned in `.nvmrc`
+- **Biome** for format + lint (`bun run check`); a versioned **pre-commit hook** (`.githooks/pre-commit`) auto-formats staged files and blocks on errors. It's wired up automatically on `bun install` (via the `prepare` script).
+
+### Releasing
+
+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.
+
+- `feat:` → minor, `fix:` → patch, `feat!:`/`BREAKING CHANGE` → major.
+- `docs:`/`chore:`/`ci:` etc. don't trigger a release.
+- Needs an **`NPM_TOKEN`** repo secret (an npm automation token); `GITHUB_TOKEN`
+  is automatic.

package/auth.js

@@ -0,0 +1,167 @@
+// Claude OAuth (same flow as Claude Code) + the authoritative usage endpoint.
+const crypto = require('node:crypto')
+const fs = require('node:fs')
+const path = require('node:path')
+const os = require('node:os')
+
+const CLIENT_ID = '9d1c250a-e61b-44d9-88ed-5944d1962f5e'
+const REDIRECT = 'https://platform.claude.com/oauth/code/callback'
+const AUTHORIZE = 'https://claude.ai/oauth/authorize'
+const TOKEN_URL = 'https://platform.claude.com/v1/oauth/token'
+const USAGE_URL = 'https://api.anthropic.com/api/oauth/usage'
+const SCOPE = 'org:create_api_key user:profile user:inference'
+const UA = 'claude-cli/2.1.181 (external, cli)'
+const TOKEN_PATH = path.join(os.homedir(), '.claude-usage-monitor', 'auth.json')
+
+const b64url = (buf) =>
+  buf.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
+
+let tokens = null // { access_token, refresh_token, expires_at }
+let pending = null // { verifier, state }
+
+function load() {
+  if (tokens) return tokens
+  try {
+    tokens = JSON.parse(fs.readFileSync(TOKEN_PATH, 'utf8'))
+  } catch {
+    tokens = null
+  }
+  return tokens
+}
+function save(t) {
+  tokens = t
+  try {
+    fs.mkdirSync(path.dirname(TOKEN_PATH), { recursive: true })
+    fs.writeFileSync(TOKEN_PATH, JSON.stringify(t, null, 2), { mode: 0o600 })
+  } catch {}
+}
+function clear() {
+  tokens = null
+  try {
+    fs.unlinkSync(TOKEN_PATH)
+  } catch {}
+}
+function isConnected() {
+  return !!load()
+}
+
+// Step 1: build the authorize URL (opens in the browser)
+function begin() {
+  const verifier = b64url(crypto.randomBytes(32))
+  const challenge = b64url(crypto.createHash('sha256').update(verifier).digest())
+  const state = b64url(crypto.randomBytes(32))
+  pending = { verifier, state }
+  const params = {
+    code: 'true',
+    client_id: CLIENT_ID,
+    response_type: 'code',
+    redirect_uri: REDIRECT,
+    scope: SCOPE,
+    code_challenge: challenge,
+    code_challenge_method: 'S256',
+    state,
+  }
+  const query = Object.entries(params)
+    .map(([k, v]) => `${k}=${encodeURIComponent(v)}`)
+    .join('&')
+  return `${AUTHORIZE}?${query}`
+}
+
+// Step 2: exchange the pasted "code#state" for tokens
+async function complete(pasted) {
+  const raw = String(pasted).trim()
+  // A directly-pasted long-lived token (e.g. from `claude setup-token`) skips
+  // the rate-limited code exchange entirely.
+  if (!raw.includes('#')) {
+    save({ access_token: raw, refresh_token: null, expires_at: Date.now() + 365 * 864e5 })
+    pending = null
+    return
+  }
+  if (!pending) throw new Error('no pending auth')
+  const [code, returnedState] = raw.split('#')
+  const res = await fetch(TOKEN_URL, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'User-Agent': UA },
+    body: JSON.stringify({
+      grant_type: 'authorization_code',
+      code,
+      state: returnedState || pending.state,
+      code_verifier: pending.verifier,
+      client_id: CLIENT_ID,
+      redirect_uri: REDIRECT,
+    }),
+  })
+  if (!res.ok) {
+    const body = await res.text().catch(() => '')
+    throw new Error(`exchange ${res.status}: ${body.slice(0, 150)}`)
+  }
+  const j = await res.json()
+  save({
+    access_token: j.access_token,
+    refresh_token: j.refresh_token,
+    expires_at: Date.now() + (j.expires_in || 3600) * 1000,
+  })
+  pending = null
+}
+
+async function refresh() {
+  const t = load()
+  if (!t?.refresh_token) throw Object.assign(new Error('no refresh token'), { status: 401 })
+  const res = await fetch(TOKEN_URL, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'User-Agent': UA },
+    body: JSON.stringify({
+      grant_type: 'refresh_token',
+      refresh_token: t.refresh_token,
+      client_id: CLIENT_ID,
+    }),
+  })
+  if (!res.ok) throw Object.assign(new Error('refresh failed'), { status: res.status })
+  const j = await res.json()
+  save({
+    access_token: j.access_token,
+    refresh_token: j.refresh_token || t.refresh_token,
+    expires_at: Date.now() + (j.expires_in || 3600) * 1000,
+  })
+}
+
+async function validToken() {
+  const t = load()
+  if (!t) throw Object.assign(new Error('not connected'), { status: 401 })
+  if (!t.expires_at || t.expires_at - Date.now() < 60000) await refresh()
+  return load().access_token
+}
+
+function win(o) {
+  return o && typeof o.utilization === 'number'
+    ? { pct: o.utilization, resetMs: o.resets_at ? Date.parse(o.resets_at) - Date.now() : null }
+    : null
+}
+
+// Step 3: fetch the authoritative usage
+async function fetchUsage() {
+  const token = await validToken()
+  const res = await fetch(USAGE_URL, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      'anthropic-beta': 'oauth-2025-04-20',
+      'anthropic-version': '2023-06-01',
+      'User-Agent': UA,
+    },
+  })
+  if (!res.ok) {
+    const body = await res.text().catch(() => '')
+    throw Object.assign(new Error(`usage ${res.status}: ${body.slice(0, 150)}`), {
+      status: res.status,
+    })
+  }
+  const j = await res.json()
+  return {
+    session: win(j.five_hour) || { pct: 0, resetMs: null },
+    week: win(j.seven_day) || { pct: 0, resetMs: null },
+    sonnet: win(j.seven_day_sonnet),
+    opus: win(j.seven_day_opus),
+  }
+}
+
+module.exports = { begin, complete, fetchUsage, clear, isConnected }

package/bin/clauddy.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+// Entry point when installed from npm / run via `bunx claude-usage-monitor`:
+// spawn the Electron runtime pointed at the app's main process.
+const { spawn } = require('node:child_process')
+const path = require('node:path')
+const electron = require('electron')
+
+const child = spawn(electron, [path.join(__dirname, '..', 'main.js')], {
+  stdio: 'inherit',
+})
+child.on('close', (code) => process.exit(code ?? 0))

package/config.json

@@ -0,0 +1,8 @@
+{
+  "_note": "Defaults bundled with the app. User settings are saved to ~/.claude-usage-monitor/config.json. Session/weekly % come from your account (log in via Settings).",
+  "alerts": true,
+  "alertThresholds": [80, 95],
+  "pollIntervalMs": 4000,
+  "activeThresholdMs": 8000,
+  "sleepThresholdMs": 300000
+}

package/main.js

@@ -0,0 +1,256 @@
+const { app, BrowserWindow, ipcMain, screen, Notification, shell } = require('electron')
+const path = require('node:path')
+const fs = require('node:fs')
+const os = require('node:os')
+const { getUsage } = require('./usage')
+const auth = require('./auth')
+
+// data dir: kept outside the project folder so moving the repo doesn't break it
+const DATA_DIR = path.join(os.homedir(), '.claude-usage-monitor')
+// external config: edit without rebuilding the .app
+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')
+
+let win
+let pollTimer
+let config
+let doTick = null
+const W = 276
+
+function publicConfig(c) {
+  return {
+    plan: c.plan,
+    sessionTokenBudget: c.sessionTokenBudget,
+    weeklyTokenBudget: c.weeklyTokenBudget,
+    weeklyAnchorIso: c.weeklyAnchorIso,
+    alerts: c.alerts,
+    alertThresholds: c.alertThresholds,
+  }
+}
+
+function loadConfig() {
+  const defaults = {
+    plan: 'max5x',
+    sessionTokenBudget: 630000000,
+    weeklyTokenBudget: 3450000000,
+    weeklyAnchorIso: null,
+    alerts: true,
+    alertThresholds: [80, 95],
+    pollIntervalMs: 4000,
+    activeThresholdMs: 8000,
+    sleepThresholdMs: 300000,
+  }
+  for (const p of [EXTERNAL_CONFIG, path.join(__dirname, 'config.json')]) {
+    try {
+      return { ...defaults, ...JSON.parse(fs.readFileSync(p, 'utf8')) }
+    } catch {}
+  }
+  return defaults
+}
+
+// native notification when usage crosses a threshold
+const armed = new Set()
+function checkAlerts(config, d) {
+  if (!config.alerts || !Notification.isSupported()) return
+  const ths = config.alertThresholds || [80, 95]
+  const scopes = [
+    ['session', d.session.pct],
+    ['weekly usage', d.week.pct],
+  ]
+  for (const [name, pct] of scopes) {
+    for (const t of ths) {
+      const key = `${name}:${t}`
+      if (pct >= t) {
+        if (!armed.has(key)) {
+          armed.add(key)
+          new Notification({
+            title: 'Claude Usage Monitor',
+            body: `Your ${name} is over ${t}% — now at ${Math.round(pct)}%`,
+            silent: false,
+          }).show()
+        }
+      } else {
+        armed.delete(key) // re-arm when it drops below
+      }
+    }
+  }
+}
+
+function createWindow() {
+  config = loadConfig()
+  const { workAreaSize } = screen.getPrimaryDisplay()
+  const H = 480
+
+  win = new BrowserWindow({
+    width: W,
+    height: H,
+    x: workAreaSize.width - W - 24,
+    y: workAreaSize.height - H - 24,
+    frame: false,
+    transparent: true,
+    resizable: false,
+    alwaysOnTop: true,
+    skipTaskbar: true,
+    hasShadow: false,
+    fullscreenable: false,
+    webPreferences: {
+      preload: path.join(__dirname, 'preload.js'),
+      contextIsolation: true,
+      nodeIntegration: false,
+    },
+  })
+
+  win.setAlwaysOnTop(true, 'floating')
+  win.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true })
+  win.loadFile(path.join(__dirname, 'renderer', 'index.html'))
+
+  const tick = () => {
+    if (!win || win.isDestroyed()) return
+    try {
+      const data = getUsage(config)
+      win.webContents.send('usage', data)
+      checkAlerts(config, data)
+    } catch (err) {
+      win.webContents.send('usage-error', String(err))
+    }
+  }
+  doTick = tick
+
+  win.webContents.once('did-finish-load', () => {
+    tick()
+    win.webContents.send('config', publicConfig(config))
+    win.webContents.send('auth-state', { connected: auth.isConnected() })
+    pollTimer = setInterval(tick, config.pollIntervalMs)
+    startUsagePoll()
+    watchDebug()
+  })
+}
+
+// resize the window to fit the content
+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)
+  const { workAreaSize } = screen.getPrimaryDisplay()
+  win.setPosition(workAreaSize.width - width - 24, workAreaSize.height - height - 24)
+})
+
+ipcMain.on('open-usage', () => shell.openExternal('https://claude.ai/settings/usage'))
+
+// watch the debug file; forward forced states to the renderer
+function watchDebug() {
+  fs.watchFile(DEBUG_FILE, { interval: 400 }, () => {
+    if (!win || win.isDestroyed()) return
+    try {
+      const txt = fs.readFileSync(DEBUG_FILE, 'utf8').trim()
+      win.webContents.send('debug-state', txt ? JSON.parse(txt) : null)
+    } catch {}
+  })
+}
+
+// ---- real usage via OAuth (authoritative %), polled slowly with 429 backoff ----
+let usageTimer = null
+let usageBackoff = 5 * 60 * 1000
+function scheduleUsagePoll() {
+  clearTimeout(usageTimer)
+  if (auth.isConnected()) usageTimer = setTimeout(pollUsage, usageBackoff)
+}
+async function pollUsage() {
+  try {
+    const u = await auth.fetchUsage()
+    usageBackoff = 5 * 60 * 1000
+    if (win && !win.isDestroyed()) win.webContents.send('real-usage', u)
+  } catch (e) {
+    if (e && e.status === 429) {
+      usageBackoff = Math.min(usageBackoff * 2, 30 * 60 * 1000)
+    } else if (e && e.status === 401) {
+      auth.clear()
+      if (win && !win.isDestroyed()) {
+        win.webContents.send('auth-state', { connected: false })
+        win.webContents.send('real-usage', null)
+      }
+    }
+  }
+  scheduleUsagePoll()
+}
+function startUsagePoll() {
+  if (auth.isConnected()) pollUsage()
+}
+
+ipcMain.on('auth-start', () => shell.openExternal(auth.begin()))
+ipcMain.on('auth-code', async (_e, code) => {
+  const ok = () => {
+    if (win && !win.isDestroyed()) {
+      win.webContents.send('auth-state', { connected: true })
+      win.webContents.send('auth-result', { ok: true })
+    }
+  }
+  try {
+    await auth.complete(code)
+    usageBackoff = 5 * 60 * 1000
+    try {
+      const u = await auth.fetchUsage() // validate the token
+      ok()
+      if (win && !win.isDestroyed()) win.webContents.send('real-usage', u)
+    } catch (e) {
+      if (e && e.status === 429) {
+        // token is fine, the usage endpoint is just throttled — keep it and retry later
+        ok()
+      } else {
+        throw e
+      }
+    }
+    scheduleUsagePoll()
+  } catch (err) {
+    auth.clear() // don't keep an invalid token
+    if (win && !win.isDestroyed())
+      win.webContents.send('auth-result', { ok: false, error: String(err?.message || err) })
+  }
+})
+ipcMain.on('auth-logout', () => {
+  auth.clear()
+  clearTimeout(usageTimer)
+  if (win && !win.isDestroyed()) {
+    win.webContents.send('auth-state', { connected: false })
+    win.webContents.send('real-usage', null)
+  }
+})
+
+ipcMain.on('save-config', (_e, patch) => {
+  let obj = {}
+  for (const p of [EXTERNAL_CONFIG, path.join(__dirname, 'config.json')]) {
+    try {
+      obj = JSON.parse(fs.readFileSync(p, 'utf8'))
+      break
+    } catch {}
+  }
+  Object.assign(obj, patch)
+  try {
+    fs.mkdirSync(path.dirname(EXTERNAL_CONFIG), { recursive: true })
+    fs.writeFileSync(EXTERNAL_CONFIG, JSON.stringify(obj, null, 2))
+  } catch {}
+  config = loadConfig()
+  armed.clear() // re-arm alerts with new thresholds
+  if (doTick) doTick()
+  if (win && !win.isDestroyed()) win.webContents.send('config', publicConfig(config))
+})
+
+ipcMain.on('quit', () => app.quit())
+
+app.whenReady().then(() => {
+  createWindow()
+  // open at login (packaged app only)
+  if (app.isPackaged) {
+    app.setLoginItemSettings({ openAtLogin: true, openAsHidden: false })
+  }
+})
+
+app.on('window-all-closed', () => {
+  if (pollTimer) clearInterval(pollTimer)
+  fs.unwatchFile(DEBUG_FILE)
+  app.quit()
+})
+
+if (process.platform === 'darwin' && app.dock) app.dock.hide()

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "clauddy",
+  "version": "1.0.0",
+  "description": "A cute desktop pet that tracks your Claude Code usage",
+  "main": "main.js",
+  "bin": {
+    "clauddy": "bin/clauddy.js"
+  },
+  "files": [
+    "bin",
+    "main.js",
+    "preload.js",
+    "usage.js",
+    "auth.js",
+    "config.json",
+    "renderer"
+  ],
+  "scripts": {
+    "start": "electron .",
+    "pack": "node scripts/build-app.js --dir",
+    "dist": "node scripts/build-app.js --mac zip",
+    "icon": "bash build-icon.sh",
+    "gifs": "electron tools/capture/capture.js",
+    "format": "biome format --write .",
+    "lint": "biome lint .",
+    "check": "biome check --write .",
+    "prepare": "git config core.hooksPath .githooks || true"
+  },
+  "author": "Renato",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/renatoaug/claude-usage-monitor.git"
+  },
+  "homepage": "https://github.com/renatoaug/claude-usage-monitor#readme",
+  "bugs": {
+    "url": "https://github.com/renatoaug/claude-usage-monitor/issues"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "usage",
+    "monitor",
+    "desktop-pet",
+    "electron",
+    "macos",
+    "menubar",
+    "widget"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "packageManager": "bun@1.3.14",
+  "engines": {
+    "node": ">=24"
+  },
+  "build": {
+    "appId": "com.renato.claude-usage-monitor",
+    "productName": "Claude Usage Monitor",
+    "directories": {
+      "output": "dist"
+    },
+    "files": [
+      "main.js",
+      "preload.js",
+      "usage.js",
+      "auth.js",
+      "config.json",
+      "renderer/**"
+    ],
+    "mac": {
+      "category": "public.app-category.developer-tools",
+      "target": "dir",
+      "identity": null,
+      "icon": "build/icon.icns"
+    }
+  },
+  "dependencies": {
+    "electron": "^42.4.1"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.5.0",
+    "@semantic-release/exec": "^7.1.0",
+    "electron-builder": "^26.15.3",
+    "semantic-release": "^25.0.5"
+  }
+}