claude-code-pulsify 1.0.2 → 1.1.1

package/README.md

@@ -34,6 +34,18 @@ npx claude-code-pulsify@latest --uninstall
 - **Context monitor** -- Warns at 65% and 75% context usage via PostToolUse hook
 - **Update checker** -- Background version check on session start, non-blocking
 
+## Checking your installed version
+
+```bash
+npx claude-code-pulsify --status
+```
+
+This shows the currently installed version, hooks location, and whether an update is available.
+
+You can also check manually:
+- **VERSION file:** `~/.claude/hooks/claude-code-pulsify/VERSION`
+- **Update cache:** `~/.claude/cache/claude-code-pulsify-update.json` — written on each session start, contains `installed`, `latest`, and `updateAvailable` fields
+
 ## Configuration
 
 Respects the `CLAUDE_CONFIG_DIR` environment variable. Defaults to `~/.claude`.

package/bin/install.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 'use strict'
 
-const fs = require('fs')
-const path = require('path')
+const fs = require('node:fs')
+const path = require('node:path')
 
 const PACKAGE_VERSION = require('../package.json').version
 const HOOKS_SOURCE = path.join(__dirname, '..', 'hooks')
-const HOOK_FILES = ['statusline.js', 'context-monitor.js', 'check-update.js']
+const HOOK_FILES = ['statusline.js', 'context-monitor.js', 'check-update.js', 'check-update-worker.js']
 
-const configDir = process.env.CLAUDE_CONFIG_DIR || path.join(require('os').homedir(), '.claude')
+const configDir = process.env.CLAUDE_CONFIG_DIR || path.join(require('node:os').homedir(), '.claude')
 const hooksTarget = path.join(configDir, 'hooks', 'claude-code-pulsify')
 const settingsPath = path.join(configDir, 'settings.json')
 
@@ -17,8 +17,15 @@ const settingsPath = path.join(configDir, 'settings.json')
 function readJSON(filePath) {
   try {
     return JSON.parse(fs.readFileSync(filePath, 'utf8'))
-  } catch {
-    return {}
+  } catch (err) {
+    if (err.code === 'ENOENT') return {}
+    if (err instanceof SyntaxError) {
+      const backupPath = `${filePath}.backup-${Date.now()}`
+      console.warn(`  ⚠ Parse error in ${filePath} — backing up to ${backupPath}`)
+      fs.copyFileSync(filePath, backupPath)
+      return {}
+    }
+    throw err
   }
 }
 
@@ -38,7 +45,6 @@ function upsertHookArray(arr, newEntry) {
   } else {
     arr.push(newEntry)
   }
-  return arr
 }
 
 function removeFromHookArray(arr) {
@@ -63,7 +69,17 @@ function install() {
   fs.writeFileSync(path.join(hooksTarget, 'VERSION'), PACKAGE_VERSION, 'utf8')
   console.log(`  Wrote VERSION (${PACKAGE_VERSION})`)
 
-  // 3. Patch settings.json
+  // 3. Clear update cache so stale "update available" indicators don't persist after install.
+  //    The background worker will refresh it on next session.
+  const cachePath = path.join(configDir, 'cache', 'claude-code-pulsify-update.json')
+  try {
+    fs.unlinkSync(cachePath)
+    console.log(`  Cleared update cache`)
+  } catch {
+    // Doesn't exist — fine
+  }
+
+  // 4. Patch settings.json
   const settings = readJSON(settingsPath)
 
   // statusLine
@@ -160,6 +176,26 @@ const args = process.argv.slice(2)
 
 if (args.includes('--version')) {
   console.log(PACKAGE_VERSION)
+} else if (args.includes('--status')) {
+  const versionFile = path.join(hooksTarget, 'VERSION')
+  const cachePath = path.join(configDir, 'cache', 'claude-code-pulsify-update.json')
+  const installed = fs.existsSync(versionFile) ? fs.readFileSync(versionFile, 'utf8').trim() : null
+  if (!installed) {
+    console.log('claude-code-pulsify is not installed.')
+    process.exit(1)
+  }
+  console.log(`Installed: v${installed}`)
+  console.log(`Hooks:     ${hooksTarget}`)
+  try {
+    const cache = JSON.parse(fs.readFileSync(cachePath, 'utf8'))
+    if (cache.updateAvailable && cache.latest) {
+      console.log(`Latest:    v${cache.latest} (update available)`)
+    } else {
+      console.log(`Latest:    v${cache.latest || installed} (up to date)`)
+    }
+  } catch {
+    console.log(`Latest:    unknown (run a Claude Code session to check)`)
+  }
 } else if (args.includes('--uninstall')) {
   uninstall()
 } else {

package/hooks/check-update-worker.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+'use strict'
+
+/**
+ * Background worker for checking npm updates.
+ * Invoked as a detached process by check-update.js.
+ *
+ * Expected environment variables:
+ *   PULSIFY_CACHE_PATH  — path to write the update cache JSON
+ *   PULSIFY_CACHE_DIR   — parent directory (created if missing)
+ *   PULSIFY_INSTALLED   — currently installed version string
+ */
+
+const { execSync } = require('node:child_process')
+const fs = require('node:fs')
+
+const NPM_VIEW_TIMEOUT_MS = 10000
+
+const cachePath = process.env.PULSIFY_CACHE_PATH
+const cacheDir = process.env.PULSIFY_CACHE_DIR
+const installed = process.env.PULSIFY_INSTALLED
+
+if (!cachePath || !cacheDir || !installed) {
+  process.exit(1)
+}
+
+try {
+  const latest = execSync('npm view claude-code-pulsify version', {
+    timeout: NPM_VIEW_TIMEOUT_MS,
+    encoding: 'utf8',
+    stdio: ['pipe', 'pipe', 'pipe'],
+  }).trim()
+  fs.mkdirSync(cacheDir, { recursive: true })
+  fs.writeFileSync(
+    cachePath,
+    JSON.stringify({
+      installed,
+      latest,
+      updateAvailable: latest.localeCompare(installed, undefined, { numeric: true }) > 0,
+      checkedAt: Date.now(),
+    }),
+  )
+} catch {
+  // Network error or npm not available — silently ignore
+}

package/hooks/check-update.js

@@ -3,15 +3,15 @@
 
 /**
  * SessionStart hook -- background version check for claude-code-pulsify.
- * Spawns a detached process to compare installed version vs npm latest,
+ * Spawns a detached worker process to compare installed version vs npm latest,
  * writes result to a cache file that statusline.js reads.
  */
 
-const { spawn } = require('child_process')
-const fs = require('fs')
-const path = require('path')
+const { spawn } = require('node:child_process')
+const fs = require('node:fs')
+const path = require('node:path')
 
-const configDir = process.env.CLAUDE_CONFIG_DIR || path.join(require('os').homedir(), '.claude')
+const configDir = process.env.CLAUDE_CONFIG_DIR || path.join(require('node:os').homedir(), '.claude')
 const hooksDir = path.join(configDir, 'hooks', 'claude-code-pulsify')
 const cacheDir = path.join(configDir, 'cache')
 const cachePath = path.join(cacheDir, 'claude-code-pulsify-update.json')
@@ -32,36 +32,24 @@ async function main() {
     return // No VERSION file — not installed properly
   }
 
-  // Spawn detached background check so we don't block session startup
-  const script = `
-    const { execSync } = require('child_process');
-    const fs = require('fs');
-    const cachePath = ${JSON.stringify(cachePath)};
-    const cacheDir = ${JSON.stringify(cacheDir)};
-    const installed = ${JSON.stringify(installed)};
-    try {
-      const latest = execSync('npm view claude-code-pulsify version', {
-        timeout: 10000,
-        encoding: 'utf8',
-        stdio: ['pipe', 'pipe', 'pipe']
-      }).trim();
-      fs.mkdirSync(cacheDir, { recursive: true });
-      fs.writeFileSync(cachePath, JSON.stringify({
-        installed,
-        latest,
-        updateAvailable: latest.localeCompare(installed, undefined, { numeric: true }) > 0,
-        checkedAt: Date.now()
-      }));
-    } catch {
-      // Network error or npm not available — silently ignore
-    }
-  `
-
-  const child = spawn(process.execPath, ['-e', script], {
+  // Spawn detached background worker so we don't block session startup
+  const workerPath = path.join(__dirname, 'check-update-worker.js')
+  const child = spawn(process.execPath, [workerPath], {
     detached: true,
     stdio: 'ignore',
+    env: {
+      ...process.env,
+      PULSIFY_CACHE_PATH: cachePath,
+      PULSIFY_CACHE_DIR: cacheDir,
+      PULSIFY_INSTALLED: installed,
+    },
   })
   child.unref()
 }
 
-main().catch(() => process.exit(0))
+main().catch((err) => {
+  if (process.env.CLAUDE_PULSIFY_DEBUG) {
+    process.stderr.write(`[pulsify:check-update] ${err.message}\n`)
+  }
+  process.exit(0)
+})

package/hooks/context-monitor.js

@@ -7,8 +7,8 @@
  * warnings when context is running low.
  */
 
-const fs = require('fs')
-const path = require('path')
+const fs = require('node:fs')
+const path = require('node:path')
 
 // Thresholds on "used percentage" (normalized, 0-100)
 const WARNING_THRESHOLD = 65 // remaining ~35% usable
@@ -17,9 +17,16 @@ const CRITICAL_THRESHOLD = 75 // remaining ~25% usable
 // Debounce: minimum tool calls between repeated warnings at the same severity
 const DEBOUNCE_COUNT = 5
 
+// Bridge data older than this is considered stale and ignored
+const BRIDGE_STALE_MS = 60_000
+
+function sanitizeId(id) {
+  return id.replace(/[^a-zA-Z0-9_-]/g, '')
+}
+
 // State file to track debounce across invocations
 function getStateFile(sessionId) {
-  return `/tmp/claude-ctx-monitor-state-${sessionId}.json`
+  return `/tmp/claude-ctx-monitor-state-${sanitizeId(sessionId)}.json`
 }
 
 function readState(sessionId) {
@@ -55,7 +62,7 @@ async function main() {
   if (!sessionId) return
 
   // Read bridge file from statusline
-  const bridgePath = `/tmp/claude-ctx-${sessionId}.json`
+  const bridgePath = `/tmp/claude-ctx-${sanitizeId(sessionId)}.json`
   let metrics
   try {
     metrics = JSON.parse(fs.readFileSync(bridgePath, 'utf8'))
@@ -63,8 +70,8 @@ async function main() {
     return // No bridge file yet -- statusline hasn't run
   }
 
-  // Check staleness (>60s old)
-  if (Date.now() - (metrics.timestamp || 0) > 60_000) return
+  // Check staleness
+  if (Date.now() - (metrics.timestamp || 0) > BRIDGE_STALE_MS) return
 
   const usedPct = metrics.used_percentage
   if (usedPct == null) return
@@ -112,4 +119,9 @@ async function main() {
   }
 }
 
-main().catch(() => process.exit(0))
+main().catch((err) => {
+  if (process.env.CLAUDE_PULSIFY_DEBUG) {
+    process.stderr.write(`[pulsify:context-monitor] ${err.message}\n`)
+  }
+  process.exit(0)
+})

package/hooks/statusline.js

@@ -7,8 +7,8 @@
  * and writes a bridge file for the context monitor.
  */
 
-const fs = require('fs')
-const path = require('path')
+const fs = require('node:fs')
+const path = require('node:path')
 
 // ANSI helpers
 const ESC = '\x1b['
@@ -28,9 +28,18 @@ const CYAN = FG(80, 200, 220)
 
 const SEPARATOR = `${GRAY}\u2502${RESET}`
 
-// Autocompact kicks in around 16.5% remaining -- normalize so bar reflects usable context
+const PROGRESS_BAR_SEGMENTS = 15
+const MAX_TASK_LABEL_LENGTH = 40
+
+// Claude's autocompact kicks in around 16.5% remaining context.
+// We normalize the bar so 0% = empty, 100% = autocompact threshold,
+// giving users a view of their *usable* context rather than total.
 const AUTOCOMPACT_BUFFER = 16.5
 
+function sanitizeId(id) {
+  return id.replace(/[^a-zA-Z0-9_-]/g, '')
+}
+
 function normalizeUsage(remainingPct) {
   // remaining_percentage goes from 100 (empty) to 0 (full)
   // usable range is 100 down to ~16.5 (autocompact buffer)
@@ -41,21 +50,21 @@ function normalizeUsage(remainingPct) {
 }
 
 function getBarColor(usedPct) {
-  if (usedPct < 50) return { fg: GREEN, label: GREEN }
-  if (usedPct < 65) return { fg: YELLOW, label: YELLOW }
-  if (usedPct < 80) return { fg: ORANGE, label: ORANGE }
-  return { fg: RED, label: RED }
+  if (usedPct < 50) return GREEN
+  if (usedPct < 65) return YELLOW
+  if (usedPct < 80) return ORANGE
+  return RED
 }
 
-function buildProgressBar(usedPct, segments = 15) {
-  const filled = Math.round((usedPct / 100) * segments)
-  const empty = segments - filled
-  const colors = getBarColor(usedPct)
+function buildProgressBar(usedPct) {
+  const filled = Math.round((usedPct / 100) * PROGRESS_BAR_SEGMENTS)
+  const empty = PROGRESS_BAR_SEGMENTS - filled
+  const color = getBarColor(usedPct)
   const emphasis = usedPct >= 80 ? BOLD : ''
 
-  const filledBar = `${emphasis}${colors.fg}${'█'.repeat(filled)}${RESET}`
+  const filledBar = `${emphasis}${color}${'█'.repeat(filled)}${RESET}`
   const emptyBar = `${GRAY}${'░'.repeat(empty)}${RESET}`
-  const pctLabel = `${colors.label}${BOLD}${Math.round(usedPct)}%${RESET}`
+  const pctLabel = `${color}${BOLD}${Math.round(usedPct)}%${RESET}`
 
   return `${filledBar}${emptyBar} ${pctLabel}`
 }
@@ -65,11 +74,11 @@ function getActiveTask(data) {
   const active = todos.find((t) => t.status === 'in_progress') || todos.find((t) => t.status === 'pending')
   if (!active) return null
   const label = active.content || active.description || ''
-  return label.length > 40 ? label.slice(0, 37) + '...' : label
+  return label.length > MAX_TASK_LABEL_LENGTH ? label.slice(0, MAX_TASK_LABEL_LENGTH - 3) + '...' : label
 }
 
 function getUpdateIndicator() {
-  const configDir = process.env.CLAUDE_CONFIG_DIR || path.join(require('os').homedir(), '.claude')
+  const configDir = process.env.CLAUDE_CONFIG_DIR || path.join(require('node:os').homedir(), '.claude')
   const cachePath = path.join(configDir, 'cache', 'claude-code-pulsify-update.json')
   try {
     const cache = JSON.parse(fs.readFileSync(cachePath, 'utf8'))
@@ -94,14 +103,41 @@ function getGitBranch(cwd) {
 
 function writeBridgeFile(sessionId, metrics) {
   if (!sessionId) return
-  const bridgePath = `/tmp/claude-ctx-${sessionId}.json`
+  const safeId = sanitizeId(sessionId)
+  const bridgePath = `/tmp/claude-ctx-${safeId}.json`
+  const tmpPath = `${bridgePath}.tmp`
   try {
-    fs.writeFileSync(bridgePath, JSON.stringify({ ...metrics, timestamp: Date.now() }), 'utf8')
+    fs.writeFileSync(tmpPath, JSON.stringify({ ...metrics, timestamp: Date.now() }), 'utf8')
+    fs.renameSync(tmpPath, bridgePath)
   } catch {
     // Silently ignore write errors
   }
 }
 
+function formatCost(costUsd) {
+  if (!costUsd) return ''
+  if (costUsd < 1) return `${WHITE}$${costUsd.toFixed(2).replace(/0+$/, '').replace(/\.$/, '')}${RESET}`
+  const str = costUsd.toFixed(1).replace(/\.0$/, '')
+  return `${WHITE}$${str}${RESET}`
+}
+
+function formatLinesChanged(added, removed) {
+  const parts = []
+  if (added) parts.push(`${GREEN}+${added}${RESET}`)
+  if (removed) parts.push(`${RED}-${removed}${RESET}`)
+  return parts.join(' ')
+}
+
+function formatTokenCount(input, output) {
+  const total = (input || 0) + (output || 0)
+  if (!total) return ''
+  let compact
+  if (total >= 1e6) compact = `${(total / 1e6).toFixed(1)}M`
+  else if (total >= 1e3) compact = `${(total / 1e3).toFixed(1)}k`
+  else compact = `${total}`
+  return `${DIM}${compact} tok${RESET}`
+}
+
 async function main() {
   let input = ''
   for await (const chunk of process.stdin) {
@@ -141,6 +177,11 @@ async function main() {
   const dir = path.basename(cwd)
   const remainingPct = data.context_window?.remaining_percentage ?? 100
   const sessionId = data.session?.id || data.session_id || null
+  const costUsd = data.cost?.total_cost_usd ?? 0
+  const linesAdded = data.cost?.total_lines_added ?? 0
+  const linesRemoved = data.cost?.total_lines_removed ?? 0
+  const totalInputTokens = data.context_window?.total_input_tokens ?? 0
+  const totalOutputTokens = data.context_window?.total_output_tokens ?? 0
 
   // Normalize and build bar
   const usedPct = normalizeUsage(remainingPct)
@@ -165,9 +206,29 @@ async function main() {
     model,
   })
 
+  // Format new segments
+  const cost = formatCost(costUsd)
+  const lines = formatLinesChanged(linesAdded, linesRemoved)
+  const tokenCount = formatTokenCount(totalInputTokens, totalOutputTokens)
+
+  // Build segments array (only include non-empty optional segments)
+  const segments = [
+    `${WHITE}${model}${RESET}`,
+    dirLabel,
+  ]
+  if (cost) segments.push(cost)
+  if (lines) segments.push(lines)
+  const barWithTokens = tokenCount ? `${bar} ${tokenCount}` : bar
+  segments.push(barWithTokens)
+
   // Output statusline
-  const line = `${WHITE}${model}${RESET} ${SEPARATOR} ${dirLabel} ${SEPARATOR} ${bar}${taskSegment}${updateIndicator}`
+  const line = segments.join(` ${SEPARATOR} `) + taskSegment + updateIndicator
   process.stdout.write(line)
 }
 
-main().catch(() => process.exit(0))
+main().catch((err) => {
+  if (process.env.CLAUDE_PULSIFY_DEBUG) {
+    process.stderr.write(`[pulsify:statusline] ${err.message}\n`)
+  }
+  process.exit(0)
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-pulsify",
-  "version": "1.0.2",
+  "version": "1.1.1",
   "description": "Context-aware statusline and context monitor for Claude Code",
   "bin": {
     "claude-code-pulsify": "bin/install.js"