claude-discover 1.10.4 → 1.10.5

package/bin/claude/statusline.mjs

@@ -1,125 +1,125 @@
-#!/usr/bin/env node
-// Claude Code status line, installed by StatuslineSwitch. Reads the hook JSON from stdin and
-// prints one colored line — model and effort, context usage, token totals, rate-limit windows:
-//   [Opus 4.8 high] Context: ▓▓▓░░░░░░░ 32% used (45.2k, 87% cached)  |  Tokens: 1.2M total (+45.2k, 3 turns)  |  Daily: 42% used (resets in 2h 30m)
-
-import { readFileSync } from 'node:fs'
-import { styleText } from 'node:util'
-
-
-// Formatting
-const THRESHOLDS = { // (white, yellow, red)
-  context: [0, 100_000, 250_000],
-  limit:   [0, 60, 90],
-  cache:   [90, 60, 0],
-  tokens:  [0, 250_000, 1_000_000],
-  session: [0, 3_000_000, 8_000_000],
-  turns:   [0, 10, 25],
-}
-
-const NO_COLOR = process.env.NO_COLOR !== undefined // standard opt-out; styleText can't honor it for piped output, so gate here
-
-function colorize(kind, text, value = 0) {
-  const bounds = THRESHOLDS[kind]
-  const n = bounds.filter(b => value >= b).length
-  const TIERS  = [null, 'yellow', 'red'] // indexed by severity tier
-  const idx = bounds[0] < bounds.at(-1) ? n - 1 : bounds.length - n
-  const color = TIERS[idx]
-  // validateStream:false forces codes through the pipe (statusline output isn't a TTY)
-  return color && !NO_COLOR ? styleText(color, text, { validateStream: false }) : text
-}
-
-
-// Collect stdin data
-const data = JSON.parse(readFileSync(0, 'utf-8')) // fd 0 = stdin
-const modelName = data.model?.display_name?.replace('Claude ', '') || '?'
-const effort    = data.effort?.level // absent when the model doesn't support effort
-const parts = []
-
-
-
-// Context window
-const ctx = data.context_window || {}
-const total = ctx.context_window_size || 0
-if (total) {
-  const usage = ctx.current_usage || {}
-  const hit  = usage.cache_read_input_tokens || 0
-  const used = hit + (usage.cache_creation_input_tokens || 0) + (usage.input_tokens || 0)
-  const pct  = Math.round((used / total) * 100)
-  const cpct = used ? Math.floor((hit * 100) / used) : 0
-  const filled = Math.floor(pct / 10)
-  const bar    = '▓'.repeat(filled) + '░'.repeat(10 - filled)
-  const head   = colorize('context', `${bar} ${pct}% used`, used)
-  const tokens = colorize('context', `${(used / 1000).toFixed(1)}k`, used)
-  const cached = used ? colorize('cache', `${cpct}% cached`, cpct) : `${cpct}% cached`
-  parts.push(`Context: ${head} (${tokens}, ${cached})`)
-}
-
-
-
-// Total tokens (per session and per reply loop)
-function agentLoopUsage(transcriptPath) { // Read the transcript JSONL and sum API usage for the current agent loop and the whole session.
-  const lines   = readFileSync(transcriptPath, 'utf-8').split(/\r?\n/).filter(Boolean)
-  let loop      = { total: 0, turns: 0 } // last prompt-reply breakdown
-  const session = { total: 0, turns: 0 } // whole-session breakdown
-  let seen = new Set() // One API response spans multiple lines (one per content block), each repeating the usage block, so dedupe by message.id.
-
-  for (const line of lines) {
-    let e
-    try { e = JSON.parse(line) } catch { continue } // the transcript may be mid-append — skip a half-written line
-    const msg = e.message || {}
-
-    if (e.type === 'user' && !e.isMeta) {
-      const isToolReply = Array.isArray(msg.content) && msg.content.some(b => b.type === 'tool_result')
-      if (!isToolReply) { // real user prompt = new loop
-        loop = { total: 0, turns: 0 }
-        seen = new Set()
-      }
-    } else if (e.type === 'assistant' && !seen.has(msg.id)) {
-      seen.add(msg.id)
-      const u = msg.usage || {}
-      const tokens = (u.input_tokens || 0) + (u.output_tokens || 0) + (u.cache_creation_input_tokens || 0) + (u.cache_read_input_tokens || 0)
-      for (const d of [loop, session]) {
-        d.total += tokens
-        d.turns += 1
-      }
-    }
-  }
-  return [loop, session]
-}
-
-if (data.transcript_path) {
-  const [loop, session] = agentLoopUsage(data.transcript_path)
-  const fmt = n => n >= 1_000_000 ? `${(n / 1_000_000).toFixed(1)}M` : `${(n / 1000).toFixed(1)}k`
-  const tokensS = colorize('tokens',  fmt(loop.total),    loop.total)
-  const sessS   = colorize('session', fmt(session.total), session.total)
-  const turnsS  = colorize('turns', `${loop.turns} turn${loop.turns !== 1 ? 's' : ''}`, loop.turns)
-  parts.push(`Tokens: ${sessS} total (+${tokensS}, ${turnsS})`)
-}
-
-
-
-// Rate limits (5-hour and weekly windows)
-function fmtReset(resetsAt) { // Format remaining time until a unix-epoch reset, e.g. "2h 30m" (null if no timestamp).
-  if (!resetsAt) return null
-  const secs = Math.max(0, Math.floor(Number(resetsAt)) - Math.floor(Date.now() / 1000))
-  const min  = Math.floor(secs / 60) % 60
-  const hrs  = Math.floor(secs / 3600) % 24
-  const days = Math.floor(secs / 86400)
-  if (days) return `${days}d ${hrs}h`
-  if (hrs)  return `${hrs}h ${min}m`
-  return `${min}m`
-}
-
-const rl = data.rate_limits || {}
-for (const [label, window] of [['Daily', rl.five_hour], ['Weekly', rl.seven_day]]) {
-  if (!window) continue
-  const pct      = Math.floor(window.used_percentage || 0)
-  const reset    = fmtReset(window.resets_at)
-  const resetStr = reset ? ` (resets in ${reset})` : ''
-  parts.push(`${label}: ${colorize('limit', `${pct}% used${resetStr}`, pct)}`)
-}
-
-
-// Status line
-process.stdout.write(`[${modelName}${effort ? ` ${effort}` : ''}] ` + parts.join('  |  ') + '\n')
+#!/usr/bin/env node
+// Claude Code status line, installed by StatuslineSwitch. Reads the hook JSON from stdin and
+// prints one colored line — model and effort, context usage, token totals, rate-limit windows:
+//   [Opus 4.8 high] Context: ▓▓▓░░░░░░░ 32% used (45.2k, 87% cached)  |  Tokens: 1.2M total (+45.2k, 3 turns)  |  Daily: 42% used (resets in 2h 30m)
+
+import { readFileSync } from 'node:fs'
+import { styleText } from 'node:util'
+
+
+// Formatting
+const THRESHOLDS = { // (white, yellow, red)
+  context: [0, 100_000, 250_000],
+  limit:   [0, 60, 90],
+  cache:   [90, 60, 0],
+  tokens:  [0, 250_000, 1_000_000],
+  session: [0, 3_000_000, 8_000_000],
+  turns:   [0, 10, 25],
+}
+
+const NO_COLOR = process.env.NO_COLOR !== undefined // standard opt-out; styleText can't honor it for piped output, so gate here
+
+function colorize(kind, text, value = 0) {
+  const bounds = THRESHOLDS[kind]
+  const n = bounds.filter(b => value >= b).length
+  const TIERS  = [null, 'yellow', 'red'] // indexed by severity tier
+  const idx = bounds[0] < bounds.at(-1) ? n - 1 : bounds.length - n
+  const color = TIERS[idx]
+  // validateStream:false forces codes through the pipe (statusline output isn't a TTY)
+  return color && !NO_COLOR ? styleText(color, text, { validateStream: false }) : text
+}
+
+
+// Collect stdin data
+const data = JSON.parse(readFileSync(0, 'utf-8')) // fd 0 = stdin
+const modelName = data.model?.display_name?.replace('Claude ', '') || '?'
+const effort    = data.effort?.level // absent when the model doesn't support effort
+const parts = []
+
+
+
+// Context window
+const ctx = data.context_window || {}
+const total = ctx.context_window_size || 0
+if (total) {
+  const usage = ctx.current_usage || {}
+  const hit  = usage.cache_read_input_tokens || 0
+  const used = hit + (usage.cache_creation_input_tokens || 0) + (usage.input_tokens || 0)
+  const pct  = Math.round((used / total) * 100)
+  const cpct = used ? Math.floor((hit * 100) / used) : 0
+  const filled = Math.floor(pct / 10)
+  const bar    = '▓'.repeat(filled) + '░'.repeat(10 - filled)
+  const head   = colorize('context', `${bar} ${pct}% used`, used)
+  const tokens = colorize('context', `${(used / 1000).toFixed(1)}k`, used)
+  const cached = used ? colorize('cache', `${cpct}% cached`, cpct) : `${cpct}% cached`
+  parts.push(`Context: ${head} (${tokens}, ${cached})`)
+}
+
+
+
+// Total tokens (per session and per reply loop)
+function agentLoopUsage(transcriptPath) { // Read the transcript JSONL and sum API usage for the current agent loop and the whole session.
+  const lines   = readFileSync(transcriptPath, 'utf-8').split(/\r?\n/).filter(Boolean)
+  let loop      = { total: 0, turns: 0 } // last prompt-reply breakdown
+  const session = { total: 0, turns: 0 } // whole-session breakdown
+  let seen = new Set() // One API response spans multiple lines (one per content block), each repeating the usage block, so dedupe by message.id.
+
+  for (const line of lines) {
+    let e
+    try { e = JSON.parse(line) } catch { continue } // the transcript may be mid-append — skip a half-written line
+    const msg = e.message || {}
+
+    if (e.type === 'user' && !e.isMeta) {
+      const isToolReply = Array.isArray(msg.content) && msg.content.some(b => b.type === 'tool_result')
+      if (!isToolReply) { // real user prompt = new loop
+        loop = { total: 0, turns: 0 }
+        seen = new Set()
+      }
+    } else if (e.type === 'assistant' && !seen.has(msg.id)) {
+      seen.add(msg.id)
+      const u = msg.usage || {}
+      const tokens = (u.input_tokens || 0) + (u.output_tokens || 0) + (u.cache_creation_input_tokens || 0) + (u.cache_read_input_tokens || 0)
+      for (const d of [loop, session]) {
+        d.total += tokens
+        d.turns += 1
+      }
+    }
+  }
+  return [loop, session]
+}
+
+if (data.transcript_path) {
+  const [loop, session] = agentLoopUsage(data.transcript_path)
+  const fmt = n => n >= 1_000_000 ? `${(n / 1_000_000).toFixed(1)}M` : `${(n / 1000).toFixed(1)}k`
+  const tokensS = colorize('tokens',  fmt(loop.total),    loop.total)
+  const sessS   = colorize('session', fmt(session.total), session.total)
+  const turnsS  = colorize('turns', `${loop.turns} turn${loop.turns !== 1 ? 's' : ''}`, loop.turns)
+  parts.push(`Tokens: ${sessS} total (+${tokensS}, ${turnsS})`)
+}
+
+
+
+// Rate limits (5-hour and weekly windows)
+function fmtReset(resetsAt) { // Format remaining time until a unix-epoch reset, e.g. "2h 30m" (null if no timestamp).
+  if (!resetsAt) return null
+  const secs = Math.max(0, Math.floor(Number(resetsAt)) - Math.floor(Date.now() / 1000))
+  const min  = Math.floor(secs / 60) % 60
+  const hrs  = Math.floor(secs / 3600) % 24
+  const days = Math.floor(secs / 86400)
+  if (days) return `${days}d ${hrs}h`
+  if (hrs)  return `${hrs}h ${min}m`
+  return `${min}m`
+}
+
+const rl = data.rate_limits || {}
+for (const [label, window] of [['Daily', rl.five_hour], ['Weekly', rl.seven_day]]) {
+  if (!window) continue
+  const pct      = Math.floor(window.used_percentage || 0)
+  const reset    = fmtReset(window.resets_at)
+  const resetStr = reset ? ` (resets in ${reset})` : ''
+  parts.push(`${label}: ${colorize('limit', `${pct}% used${resetStr}`, pct)}`)
+}
+
+
+// Status line
+process.stdout.write(`[${modelName}${effort ? ` ${effort}` : ''}] ` + parts.join('  |  ') + '\n')

package/bin/claude-discover.mjs

@@ -3,8 +3,8 @@
 // Electron binary at the package root, whose package.json main is out/main/main.js.
 import { spawn } from 'node:child_process'
 import { existsSync } from 'node:fs'
+import { access, constants } from 'node:fs/promises'
 import { fileURLToPath } from 'node:url'
-import electron from 'electron' // under plain node the electron package exports its binary path
 
 const appDir = fileURLToPath(new URL('..', import.meta.url))
 if (!existsSync(new URL('../out/main/main.js', import.meta.url))) {
@@ -12,5 +12,36 @@ if (!existsSync(new URL('../out/main/main.js', import.meta.url))) {
   process.exit(1)
 }
 
+
+if (process.platform === 'linux') { // @linux
+  // Importing electron downloads its binary on first run, which can't unzip into a root-owned `sudo npm i -g` install,
+  // so it's imported dynamically, only after this check (a static import is hoisted and would run first)
+
+  const electronDir = new URL('.', import.meta.resolve('electron'))
+  const isWritable = await access(electronDir, constants.W_OK).then(() => true, () => false)
+  if (!existsSync(new URL('path.txt', electronDir)) && !isWritable) {
+    console.error(`
+Electron can't finish installing — its folder isn't writable by your user.
+
+Global npm packages shouldn't need sudo. The recommended setup is Node from a version
+manager like nvm, which keeps global npm packages in your home folder:
+
+  sudo npm uninstall -g claude-discover
+  wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.8/install.sh | bash
+
+Then open a new terminal and run:
+
+  nvm install --lts
+  npm install -g claude-discover
+  claude-discover
+
+See https://docs.npmjs.com/resolving-eacces-permissions-errors-when-installing-packages-globally`)
+    process.exit(1)
+  }
+}
+
+
+const { default: electron } = await import('electron') // under plain node the electron package exports its binary path
+
 spawn(electron, [appDir, ...process.argv.slice(2)], { stdio: 'inherit' })
   .on('close', code => process.exit(code ?? 0))

package/bin/update.mjs

@@ -1,42 +1,42 @@
-// Updates an `npm i -g` install from outside it. AutoUpdate starts it detached as the app quits:
-// Windows locks the app's running electron.exe, so npm can only replace the package once the app is gone.
-
-import { spawn, spawnSync } from 'node:child_process'
-import path from 'node:path'
-import { setTimeout as sleep } from 'node:timers/promises'
-import { parseArgs } from 'node:util'
-
-
-// ── 1. CLI, then wait for the app to exit ────────────────────────────────────
-
-const { values, positionals: [pid, version] } = parseArgs({
-  allowPositionals: true,
-  options: {
-    'no-reopen': { type: 'boolean' },
-    'help':      { type: 'boolean', short: 'h' },
-  },
-})
-
-if (values.help || !version) {
-  console.error('Usage: node bin/update.mjs <pid> <version> [--no-reopen]')
-  process.exit(1)
-}
-
-while (true) {
-  try {
-    process.kill(Number(pid), 0)
-  } catch (err) {
-    if (err.code !== 'EPERM') break // EPERM: alive, just not ours to signal
-  }
-  await sleep(200)
-}
-
-
-// ── 2. Update and reopen ─────────────────────────────────────────────────────
-
-const { status } = spawnSync(`npm i -g claude-discover@${version} --loglevel=http`, { shell: true, stdio: 'inherit' })
-if (status !== 0) await sleep(5_000) // leaves npm's error readable before the window closes
-
-// Reopen even after a failed update; dev passes --no-reopen, as its Vite renderer died with the app
-const globalBin = path.join(spawnSync('npm root -g', { shell: true, encoding: 'utf8' }).stdout.trim(), 'claude-discover/bin/claude-discover.mjs')
-if (!values['no-reopen']) spawn(process.execPath, [globalBin], { detached: true, stdio: 'ignore' }).unref()
+// Updates an `npm i -g` install from outside it. AutoUpdate starts it detached as the app quits:
+// Windows locks the app's running electron.exe, so npm can only replace the package once the app is gone.
+
+import { spawn, spawnSync } from 'node:child_process'
+import path from 'node:path'
+import { setTimeout as sleep } from 'node:timers/promises'
+import { parseArgs } from 'node:util'
+
+
+// ── 1. CLI, then wait for the app to exit ────────────────────────────────────
+
+const { values, positionals: [pid, version] } = parseArgs({
+  allowPositionals: true,
+  options: {
+    'no-reopen': { type: 'boolean' },
+    'help':      { type: 'boolean', short: 'h' },
+  },
+})
+
+if (values.help || !version) {
+  console.error('Usage: node bin/update.mjs <pid> <version> [--no-reopen]')
+  process.exit(1)
+}
+
+while (true) {
+  try {
+    process.kill(Number(pid), 0)
+  } catch (err) {
+    if (err.code !== 'EPERM') break // EPERM: alive, just not ours to signal
+  }
+  await sleep(200)
+}
+
+
+// ── 2. Update and reopen ─────────────────────────────────────────────────────
+
+const { status } = spawnSync(`npm i -g claude-discover@${version} --loglevel=http`, { shell: true, stdio: 'inherit' })
+if (status !== 0) await sleep(5_000) // leaves npm's error readable before the window closes
+
+// Reopen even after a failed update; dev passes --no-reopen, as its Vite renderer died with the app
+const globalBin = path.join(spawnSync('npm root -g', { shell: true, encoding: 'utf8' }).stdout.trim(), 'claude-discover/bin/claude-discover.mjs')
+if (!values['no-reopen']) spawn(process.execPath, [globalBin], { detached: true, stdio: 'ignore' }).unref()

package/out/main/main.js

@@ -1,4 +1,4 @@
-import { app, dialog, BrowserWindow, shell, WebContentsView, Menu, ipcMain } from "electron";
+import { app, dialog, BrowserWindow, shell, nativeTheme, Menu, ipcMain } from "electron";
 import { EventEmitter } from "node:events";
 import os, { homedir } from "node:os";
 import path, { join, dirname, basename } from "node:path";
@@ -14,6 +14,7 @@ import semver from "semver";
 import { pathToFileURL, fileURLToPath } from "node:url";
 import windowStateKeeper from "electron-window-state";
 import contextMenu from "electron-context-menu";
+import { FindOverlay } from "electron-find-overlay";
 class ConfigFile {
   dataDir = join(homedir(), ".claude-discover");
   configFile = join(this.dataDir, "config.json");
@@ -759,6 +760,7 @@ class SessionParser {
     this.prevMessage = null;
     this.tokenTotal = 0;
     this.lastSeenTs = null;
+    this.modelId = null;
     this.commandUuids = /* @__PURE__ */ new Set();
     this.seenUuids = /* @__PURE__ */ new Set();
     this.appliedById = /* @__PURE__ */ new Map();
@@ -774,6 +776,7 @@ class SessionParser {
     if (t === "tag") meta.tag = obj.tag || null;
     if (t === "queue-operation" && obj.content?.includes("<scheduled-task")) meta.hasScheduledTask = true;
     if (t === "started" && obj.key && obj.agentId) meta.workflowAgents += 1;
+    if (t === "attachment" && obj.attachment?.type === "model") this.modelId = obj.attachment.identity?.modelId;
     if (obj.cwd && !meta.project) meta.project = obj.cwd;
     if (obj.gitBranch && !meta.gitBranch) meta.gitBranch = obj.gitBranch;
     if (obj.entrypoint && !meta.entrypoint) meta.entrypoint = obj.entrypoint;
@@ -818,9 +821,10 @@ class SessionParser {
     } else if (t === "assistant") {
       const msg = obj.message;
       if (!msg || msg.model === "<synthetic>") return true;
-      if (msg.model) {
-        if (!meta.model) meta.model = msg.model;
-        if (!meta.models.includes(msg.model)) meta.models.push(msg.model);
+      const model = this.modelId?.replace(/\[.*\]$/, "") === msg.model ? this.modelId : msg.model;
+      if (model) {
+        if (!meta.model) meta.model = model;
+        if (!meta.models.includes(model)) meta.models.push(model);
       }
       const effort = obj.perTurnEffort ?? obj.effort;
       if (effort && !meta.efforts.includes(effort)) meta.efforts.push(effort);
@@ -2032,61 +2036,6 @@ function lockNavigation(contents) {
   contents.on("will-navigate", block);
   contents.on("will-redirect", block);
 }
-const __dirname$2 = path.dirname(fileURLToPath(import.meta.url));
-const DEV_URL$1 = process.env.ELECTRON_RENDERER_URL;
-const WIDTH = 320, HEIGHT = 56, MARGIN = 6;
-class FindBar {
-  constructor(win) {
-    this.win = win;
-    this.view = new WebContentsView({
-      webPreferences: {
-        preload: path.join(__dirname$2, "../preload/findPreload.cjs"),
-        contextIsolation: true,
-        nodeIntegration: false,
-        sandbox: true
-      }
-    });
-    this.view.setBackgroundColor("#00000000");
-    lockNavigation(this.view.webContents);
-    win.contentView.addChildView(this.view);
-    this.view.setVisible(false);
-    if (DEV_URL$1) this.view.webContents.loadURL(`${DEV_URL$1}/find/find.html`);
-    else this.view.webContents.loadFile(path.join(__dirname$2, "../renderer/find/find.html"));
-    win.webContents.on("found-in-page", (_e, r) => {
-      return this.view.webContents.send("find:result", { active: r.activeMatchOrdinal, total: r.matches, id: r.requestId });
-    });
-    win.on("resize", () => {
-      if (this.visible) this.layout();
-    });
-  }
-  get visible() {
-    return this.view.getVisible();
-  }
-  layout() {
-    const [w] = this.win.getContentSize();
-    this.view.setBounds({ x: Math.max(0, w - WIDTH - MARGIN), y: MARGIN, width: WIDTH, height: HEIGHT });
-  }
-  query(text, options) {
-    this.win.webContents.findInPage(text, options);
-  }
-  stop() {
-    this.win.webContents.stopFindInPage("clearSelection");
-  }
-  show() {
-    this.layout();
-    this.view.setVisible(true);
-    this.view.webContents.focus();
-    this.view.webContents.send("find:open");
-    this.win.webContents.send("find:active", true);
-  }
-  hide() {
-    if (!this.visible) return;
-    this.view.setVisible(false);
-    this.stop();
-    this.win.webContents.focus();
-    this.win.webContents.send("find:active", false);
-  }
-}
 const __dirname$1 = path.dirname(fileURLToPath(import.meta.url));
 const DEV_URL = process.env.ELECTRON_RENDERER_URL;
 class MainWindow {
@@ -2094,6 +2043,7 @@ class MainWindow {
     this.win = null;
   }
   create() {
+    nativeTheme.themeSource = "dark";
     const state = windowStateKeeper({ defaultWidth: 1500, defaultHeight: 900 });
     this.win = new BrowserWindow({
       x: state.x,
@@ -2119,7 +2069,9 @@ class MainWindow {
     } else {
       this.win.loadFile(path.join(__dirname$1, "../renderer/index.html"));
     }
-    this.findBar = new FindBar(this.win);
+    this.findBar = new FindOverlay(this.win);
+    this.findBar.on("show", () => this.send("find:active", true));
+    this.findBar.on("hide", () => this.send("find:active", false));
     return this.win;
   }
   send(channel, payload) {
@@ -2165,8 +2117,6 @@ class Application {
     ipcMain.handle("agent:run", (e, text) => agentRunner.run(text, e.sender));
     ipcMain.handle("shell:open-link", (_e, href, baseFile) => openLinkSafely(href, baseFile));
     ipcMain.handle("deeplink:take-pending", () => deepLink?.takePending() ?? null);
-    ipcMain.on("find:query", (_e, text, options) => win.findBar?.query(text, options));
-    ipcMain.on("find:stop", () => win.findBar?.stop());
     ipcMain.on("find:close", () => win.findBar?.hide());
     ipcMain.on("claude-settings:get", (e) => e.returnValue = { claudeDir: CLAUDE_DIR });
     app.on("activate", () => {