clauddy 1.29.0 → 2.0.0

package/usage.js

@@ -1,539 +0,0 @@
-const fs = require('node:fs')
-const path = require('node:path')
-const os = require('node:os')
-
-// the Claude config dir whose logs we read. mutable because the widget can
-// switch between accounts at runtime, each one pointing at its own dir.
-const DEFAULT_CLAUDE_DIR = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude')
-let claudeDir = DEFAULT_CLAUDE_DIR
-let projectsDir = path.join(claudeDir, 'projects')
-
-// point the reader at another account's logs. fileCache survives: it is keyed
-// by absolute path, so entries from another dir can't collide — and keeping it
-// is what makes switching back to an account instant instead of a full re-scan.
-// projectLabelCache is keyed by a directory *name*, which can repeat across
-// dirs, so that one goes.
-function setClaudeDir(dir) {
-  // an account with no dir of its own reads the default one — which is still
-  // CLAUDE_CONFIG_DIR when the whole instance is isolated that way
-  const next = dir || DEFAULT_CLAUDE_DIR
-  if (next === claudeDir) return
-  claudeDir = next
-  projectsDir = path.join(claudeDir, 'projects')
-  projectLabelCache.clear()
-}
-
-function labelFor(model) {
-  if (!model) return 'desconhecido'
-  const m = model.toLowerCase()
-  const fam = m.includes('opus')
-    ? 'Opus'
-    : m.includes('sonnet')
-      ? 'Sonnet'
-      : m.includes('haiku')
-        ? 'Haiku'
-        : m.includes('fable')
-          ? 'Fable'
-          : m.includes('mythos')
-            ? 'Mythos'
-            : null
-  if (!fam) return model
-  // version after the family: opus-5, opus-4-8, haiku-4-5-<date>
-  let ver = m.match(/(?:opus|sonnet|haiku|fable|mythos)-(\d{1,2})(?:-(\d{1,2}))?(?!\d)/)
-  // legacy ids put the version before the family: claude-3-5-sonnet
-  if (!ver) ver = m.match(/-(\d)-(\d+)/)
-  if (ver) return ver[2] ? `${fam} ${ver[1]}.${ver[2]}` : `${fam} ${ver[1]}`
-  return fam
-}
-
-// Claude Code names each project directory after the working directory with
-// every `/` and `.` flattened to `-`, so `-Users-me-my-projects-clauddy` cannot
-// be reversed by string surgery alone: the separator and the names use the same
-// character. Instead of guessing, we walk the real filesystem and let it be the
-// dictionary — at each level we ask which actual child directory, once encoded
-// the same way, starts the remaining string. Longest match first, because `my`
-// and `my-projects` can both be candidates and only the longer one is right.
-const projectLabelCache = new Map()
-
-function encodePathSegment(name) {
-  return name.replace(/[/.]/g, '-')
-}
-
-// Walks as far as the filesystem allows and reports where it stopped. A project
-// that has since been moved or deleted still resolves its surviving ancestors,
-// which is what keeps the fallback label readable instead of a raw blob.
-//
-// `consumed` is the remainder as it stood *before* the last successful step.
-// That step is the only one that can have eaten into the name of a directory
-// that no longer exists — matching `qulture-identity` out of the encoded
-// `qulture-identity-web` leaves a bare `web`, which reads like a real project
-// and is not one. When the walk ends short, the caller rewinds to `consumed`
-// and shows a longer label rather than a confidently wrong one.
-function resolveProjectPath(dirName) {
-  let cur = path.sep
-  let rest = dirName
-  let consumed = null
-  while (rest) {
-    if (!rest.startsWith('-')) break
-    const tail = rest.slice(1)
-    let kids
-    try {
-      kids = fs.readdirSync(cur, { withFileTypes: true })
-    } catch {
-      break
-    }
-    let match = null
-    for (const k of kids) {
-      // symlinks count: /var is one on macOS, and people do symlink project trees
-      if (!k.isDirectory() && !k.isSymbolicLink()) continue
-      const enc = encodePathSegment(k.name)
-      // `my` and `my-projects` can both start the remainder — the longer one wins
-      if (tail !== enc && !tail.startsWith(`${enc}-`)) continue
-      if (!match || enc.length > encodePathSegment(match).length) match = k.name
-    }
-    if (!match) break
-    consumed = tail
-    cur = path.join(cur, match)
-    rest = tail.slice(encodePathSegment(match).length)
-  }
-  return { full: rest ? null : cur, consumed }
-}
-
-const LABEL_MAX = 26
-
-// The readable name for a project directory: its basename when the path still
-// exists, otherwise the raw tail. A moved or deleted project is shown as-is
-// rather than guessed at — a wrong name is worse than an ugly one.
-function projectLabel(dirName) {
-  const hit = projectLabelCache.get(dirName)
-  if (hit !== undefined) return hit
-  const { full, consumed } = resolveProjectPath(dirName)
-  let label
-  if (full) {
-    label = path.basename(full) || full
-  } else {
-    // whatever the filesystem could not account for, shown as-is
-    label = (consumed || dirName).replace(/^-+/, '')
-    if (label.length > LABEL_MAX) label = `…${label.slice(-(LABEL_MAX - 1))}`
-  }
-  projectLabelCache.set(dirName, label)
-  return label
-}
-
-function projectDirOf(file) {
-  const rel = path.relative(projectsDir, file)
-  const first = rel.split(path.sep)[0]
-  return first && first !== '..' ? first : null
-}
-
-function tokensOf(entry) {
-  const u = entry.usage || {}
-  return (
-    (u.input_tokens || 0) +
-    (u.output_tokens || 0) +
-    (u.cache_read_input_tokens || 0) +
-    (u.cache_creation_input_tokens || 0)
-  )
-}
-
-const fileCache = new Map()
-
-function walkJsonl(dir, out, cutoffMs) {
-  let items
-  try {
-    items = fs.readdirSync(dir, { withFileTypes: true })
-  } catch {
-    return
-  }
-  for (const it of items) {
-    const full = path.join(dir, it.name)
-    if (it.isDirectory()) {
-      walkJsonl(full, out, cutoffMs)
-    } else if (it.isFile() && it.name.endsWith('.jsonl')) {
-      let st
-      try {
-        st = fs.statSync(full)
-      } catch {
-        continue
-      }
-      if (st.mtimeMs < cutoffMs) continue
-      out.push({ full, st })
-    }
-  }
-}
-
-function ingestLine(entries, line) {
-  // most lines are tool results and prompts: skip them without a parse
-  if (!line.includes('"usage"')) return
-  let obj
-  try {
-    obj = JSON.parse(line)
-  } catch {
-    return
-  }
-  if (obj.type !== 'assistant' || !obj.message || !obj.message.usage) return
-  if (obj.message.model === '<synthetic>') return // Claude Code internal messages
-  const ts = Date.parse(obj.timestamp || obj.message?.timestamp || 0)
-  if (!ts) return
-  entries.push({
-    ts,
-    model: obj.message.model,
-    tokens: tokensOf({ usage: obj.message.usage }),
-    key: `${obj.message.id || ''}:${obj.requestId || obj.uuid || ''}`,
-  })
-}
-
-const CHUNK = 8 * 1024 * 1024
-
-// Session logs only ever grow, and a long one passes 500 MB: a poll reads just
-// the bytes appended since the last one, in chunks, so the main process never
-// stalls on a full re-read. A line still being written waits in `rest`.
-function parseFile(full, st) {
-  let cached = fileCache.get(full)
-  // shrunk or replaced: start over
-  if (!cached || st.size < cached.offset) {
-    cached = { offset: 0, rest: Buffer.alloc(0), entries: [] }
-    fileCache.set(full, cached)
-  }
-  if (st.size <= cached.offset) return cached.entries
-  let fd
-  try {
-    fd = fs.openSync(full, 'r')
-  } catch {
-    return cached.entries
-  }
-  try {
-    while (cached.offset < st.size) {
-      const chunk = Buffer.alloc(Math.min(CHUNK, st.size - cached.offset))
-      const n = fs.readSync(fd, chunk, 0, chunk.length, cached.offset)
-      if (n <= 0) break
-      cached.offset += n
-      const buf = Buffer.concat([cached.rest, chunk.subarray(0, n)])
-      // cut at the last newline in bytes, so a split UTF-8 character survives
-      const end = buf.lastIndexOf(0x0a)
-      if (end < 0) {
-        cached.rest = buf
-        continue
-      }
-      cached.rest = Buffer.from(buf.subarray(end + 1))
-      for (const line of buf.toString('utf8', 0, end).split('\n')) {
-        if (line) ingestLine(cached.entries, line)
-      }
-    }
-  } catch {
-    // unreadable mid-way: keep what we have, retry from the offset next poll
-  } finally {
-    fs.closeSync(fd)
-  }
-  return cached.entries
-}
-
-const DAYS = 30
-// how many projects the panel ranks before folding the rest into `other`
-const TOP_PROJECTS = 5
-const SESSION_MS = 5 * 3600 * 1000
-
-// map a Claude Code tool name to what the pet is "doing"
-const ACTIVITY_BY_TOOL = {
-  Edit: 'editing',
-  MultiEdit: 'editing',
-  Write: 'editing',
-  NotebookEdit: 'editing',
-  Read: 'reading',
-  Grep: 'reading',
-  Glob: 'reading',
-  LS: 'reading',
-  Bash: 'running',
-  BashOutput: 'running',
-  KillShell: 'running',
-  WebSearch: 'researching',
-  WebFetch: 'researching',
-  Task: 'delegating',
-  Agent: 'delegating',
-  TodoWrite: 'planning',
-  ExitPlanMode: 'planning',
-  AskUserQuestion: 'waiting',
-}
-
-// the last lines of a session log (the recent tail is plenty), or null
-function tailLines(file) {
-  try {
-    const fd = fs.openSync(file, 'r')
-    try {
-      const size = fs.fstatSync(fd).size
-      const len = Math.min(size, 65536)
-      const buf = Buffer.alloc(len)
-      fs.readSync(fd, buf, 0, len, size - len)
-      return buf.toString('utf8').split('\n').filter(Boolean)
-    } finally {
-      fs.closeSync(fd)
-    }
-  } catch {
-    return null
-  }
-}
-
-// Classify what Claude Code is doing right now by reading the tail of the most
-// recently touched session log: the latest tool_use → an activity, plan mode
-// (permission-mode) wins over everything. Returns null when there's no signal.
-function detectActivity(file) {
-  const lines = tailLines(file)
-  if (!lines) return null
-  let activity = null
-  let permMode = null
-  for (let i = lines.length - 1; i >= 0 && i >= lines.length - 80; i--) {
-    let o
-    try {
-      o = JSON.parse(lines[i])
-    } catch {
-      continue
-    }
-    if (permMode === null && (o.type === 'permission-mode' || o.type === 'mode')) {
-      const v = o.mode || o.permissionMode || o.value
-      if (typeof v === 'string') permMode = v
-    }
-    if (activity === null && o.type === 'assistant' && Array.isArray(o.message?.content)) {
-      const blocks = o.message.content
-      const tools = blocks.filter((b) => b && b.type === 'tool_use')
-      if (tools.length) activity = ACTIVITY_BY_TOOL[tools[tools.length - 1].name] || 'working'
-    }
-    if (activity !== null && permMode !== null) break
-  }
-  if (permMode === 'plan') return 'planning'
-  return activity
-}
-
-// User lines that open no turn: slash commands and their output, `!` shell
-// input, background-task notices, the compaction summary, meta attachments
-const NO_TURN =
-  /^\s*(<command-name>|<command-message>|<local-command-|<bash-|<task-notification>|This session is being continued)/
-const DONE_STOPS = new Set(['end_turn', 'stop_sequence', 'refusal'])
-const textOf = (content) =>
-  typeof content === 'string'
-    ? content
-    : Array.isArray(content)
-      ? content.map((b) => (b && b.type === 'text' ? b.text : '')).join(' ')
-      : ''
-
-// Is a turn still open? Claude Code writes nothing while a command runs or the
-// model thinks, so a quiet log proves nothing; how it ends does. A final answer
-// (and the turn_duration line after it) or an interruption closes the turn; a
-// tool call, a tool result or a prompt leaves it open. Returns true, false, or
-// null when the tail doesn't say.
-function turnOpen(lines) {
-  for (let i = lines.length - 1; i >= 0; i--) {
-    let o
-    try {
-      o = JSON.parse(lines[i])
-    } catch {
-      continue
-    }
-    if (o.isSidechain) continue
-    if (o.type === 'system') {
-      if (o.subtype === 'turn_duration') return false
-      continue
-    }
-    if (o.type === 'assistant') {
-      const stop = o.message?.stop_reason
-      if (!stop) continue
-      return !DONE_STOPS.has(stop)
-    }
-    if (o.type === 'user') {
-      const content = o.message?.content
-      if (Array.isArray(content) && content.some((b) => b?.type === 'tool_result')) return true
-      if (o.isMeta || o.isCompactSummary) continue
-      const text = textOf(content)
-      if (text.includes('[Request interrupted by user')) return false
-      if (NO_TURN.test(text)) continue
-      return true
-    }
-  }
-  return null
-}
-
-// a turn left open this long without a write was abandoned (a closed
-// terminal, a crash) — or a permission prompt nobody answered
-const OPEN_TURN_MS = 30 * 60000
-// parallel sessions and subagents each keep a log; a handful covers them
-const RECENT_LOGS = 8
-
-// Plan presets (token budgets ~= 100%). Calibrated for Max 5x from the official
-// panel (5h ~24% at 152M tokens, weekly ~62% at 2.14B); Pro/Max20x scaled by the
-// plan multiplier. ESTIMATES — Anthropic doesn't publish exact numbers.
-const PLAN_BUDGETS = {
-  pro: { session: 126e6, week: 690e6 },
-  max5x: { session: 630e6, week: 3450e6 },
-  max20x: { session: 2520e6, week: 13800e6 },
-}
-
-function getUsage(config) {
-  const now = Date.now()
-  const dayMs = 24 * 3600 * 1000
-  const startOfToday = new Date()
-  startOfToday.setHours(0, 0, 0, 0)
-  const todayMs = startOfToday.getTime()
-  let weekStart = now - 7 * dayMs
-  let weekResetMs = null
-  if (config.weeklyAnchorIso) {
-    const anchor = Date.parse(config.weeklyAnchorIso)
-    if (!Number.isNaN(anchor)) {
-      const period = 7 * dayMs
-      const lastReset = anchor + Math.floor((now - anchor) / period) * period
-      weekStart = lastReset
-      weekResetMs = lastReset + period - now
-    }
-  }
-  const start30 = todayMs - (DAYS - 1) * dayMs
-  const fiveMinAgo = now - 5 * 60000
-  const recentCutoff = now - 12 * 3600 * 1000
-  const scanCutoff = start30 - dayMs
-
-  const files = []
-  walkJsonl(projectsDir, files, scanCutoff)
-
-  let lastMtime = 0
-  let newestFile = null
-  for (const f of files) {
-    if (f.st.mtimeMs > lastMtime) {
-      lastMtime = f.st.mtimeMs
-      newestFile = f.full
-    }
-  }
-
-  const seen = new Set()
-  let todayTokens = 0
-  let weekTokens = 0
-  let monthTokens = 0
-  const byModel = new Map() // tokens per model, 7 days
-  const byProject = new Map() // tokens per project, 7 days
-  const days30 = new Array(DAYS).fill(0) // tokens per day
-  const recent = [] // last 12h, to detect the 5h session
-  let last5mTokens = 0
-
-  for (const f of files) {
-    const entries = parseFile(f.full, f.st)
-    const dir = projectDirOf(f.full)
-    const proj = dir ? projectLabel(dir) : null
-    for (const e of entries) {
-      if (e.ts < start30) continue
-      if (e.key && e.key !== ':' && seen.has(e.key)) continue
-      if (e.key && e.key !== ':') seen.add(e.key)
-      const t = e.tokens
-      monthTokens += t
-
-      const dayIdx = Math.min(DAYS - 1, Math.max(0, Math.floor((e.ts - start30) / dayMs)))
-      days30[dayIdx] += t
-
-      if (e.ts >= weekStart) {
-        weekTokens += t
-        const lbl = labelFor(e.model)
-        byModel.set(lbl, (byModel.get(lbl) || 0) + t)
-        if (proj) byProject.set(proj, (byProject.get(proj) || 0) + t)
-      }
-      if (e.ts >= todayMs) todayTokens += t
-      if (e.ts >= recentCutoff) recent.push({ ts: e.ts, tokens: t })
-      if (e.ts >= fiveMinAgo) last5mTokens += t
-    }
-  }
-
-  // 5h session window (like /usage "Current session")
-  recent.sort((a, b) => a.ts - b.ts)
-  let sStart = null
-  let sEnd = null
-  for (const e of recent) {
-    if (sStart === null || e.ts >= sEnd) {
-      sStart = e.ts
-      sEnd = sStart + SESSION_MS
-    }
-  }
-  const planB = PLAN_BUDGETS[config.plan]
-  const sessionBudget = planB ? planB.session : config.sessionTokenBudget
-  const weeklyBudget = planB ? planB.week : config.weeklyTokenBudget
-
-  const session = { tokens: 0, pct: 0, resetMs: 0, active: false }
-  if (sStart !== null && now < sEnd) {
-    let tk = 0
-    for (const e of recent) if (e.ts >= sStart && e.ts < sEnd) tk += e.tokens
-    session.tokens = tk
-    session.active = true
-    session.resetMs = sEnd - now
-    session.pct = sessionBudget ? Math.min(100, (tk / sessionBudget) * 100) : 0
-  }
-
-  const weekPct = weeklyBudget ? Math.min(100, (weekTokens / weeklyBudget) * 100) : 0
-
-  const lastActivityMs = lastMtime ? now - lastMtime : Infinity
-  // Working means a turn is open in one of the recent logs, even when a long
-  // command or a slow answer has kept it quiet for minutes. A log with nothing
-  // to say falls back to the old rule: written in the last few seconds.
-  let openFile = null
-  const recentLogs = files
-    .filter((f) => now - f.st.mtimeMs <= OPEN_TURN_MS)
-    .sort((a, b) => b.st.mtimeMs - a.st.mtimeMs)
-    .slice(0, RECENT_LOGS)
-  let newestSays = null
-  for (const [i, f] of recentLogs.entries()) {
-    const lines = tailLines(f.full)
-    const open = lines ? turnOpen(lines) : null
-    if (i === 0) newestSays = open
-    if (open) {
-      openFile = f.full
-      break
-    }
-  }
-  const quietRule = newestSays === null && lastActivityMs <= (config.activeThresholdMs || 20000)
-  const active = !!openFile || quietRule
-  const sleeping = !active && lastActivityMs >= (config.sleepThresholdMs || 300000)
-
-  // what Claude is doing right now (only meaningful while active)
-  const activeFile = openFile || (quietRule ? newestFile : null)
-  const activity = activeFile ? detectActivity(activeFile) || (openFile ? 'working' : null) : null
-
-  const byModelArr = [...byModel.entries()]
-    .map(([label, tokens]) => ({ label, tokens }))
-    .sort((a, b) => b.tokens - a.tokens)
-
-  // ranked, then everything past the top N folded into one row — a machine with
-  // 40 project directories must not turn the panel into a 40-row list.
-  const ranked = [...byProject.entries()]
-    .map(([label, tokens]) => ({ label, tokens }))
-    .sort((a, b) => b.tokens - a.tokens)
-  const byProjectArr = ranked.slice(0, TOP_PROJECTS)
-  const rest = ranked.slice(TOP_PROJECTS)
-  if (rest.length) {
-    byProjectArr.push({
-      label: `other · ${rest.length}`,
-      tokens: rest.reduce((n, p) => n + p.tokens, 0),
-    })
-  }
-
-  return {
-    session,
-    week: { tokens: weekTokens, pct: weekPct, resetMs: weekResetMs },
-    today: { tokens: todayTokens },
-    byModel: byModelArr,
-    byProject: byProjectArr,
-    days30,
-    monthTokens,
-    tokensPerMin: Math.round(last5mTokens / 5),
-    active,
-    sleeping,
-    activity,
-    lastActivityMs,
-    ts: now,
-  }
-}
-
-// labelFor/tokensOf/detectActivity are exported for the tests — they're the
-// parts that decode Claude Code's log format, which is the thing most likely
-// to change out from under us.
-module.exports = {
-  getUsage,
-  setClaudeDir,
-  labelFor,
-  projectLabel,
-  tokensOf,
-  detectActivity,
-  turnOpen,
-  PLAN_BUDGETS,
-}