@alyibrahim/claude-statusline 1.3.1 → 1.4.0

package/README.md

@@ -4,7 +4,7 @@
 [![npm](https://img.shields.io/npm/v/@alyibrahim/claude-statusline)](https://www.npmjs.com/package/@alyibrahim/claude-statusline)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 
-**A rich, fast statusline for [Claude Code](https://claude.ai/code)** — shows model, git branch, context usage, rate limits, session cost, and real-time token consumption after every response.
+**A rich, fast statusline for [Claude Code](https://claude.ai/code)** — shows model, git branch, context usage, rate limits, session cost, and split input/output token counts after every response.
 
 Runs as a **compiled Rust binary** (~5ms startup vs ~100ms for Node.js). Zero shell dependencies. One install command.
 
@@ -28,14 +28,14 @@ Done. The statusline configures itself automatically. Restart Claude Code to see
 
 **Line 1** — Model name · Effort level · Active subagents · Current task · Directory `(branch +commits)` · Context bar
 
-**Line 2** — Weekly token usage · 5h usage · Reset countdown *(Pro/Max)* — or — Session cost *(API key)* · Session token count
+**Line 2** — Weekly token usage · 5h usage · Reset countdown *(Pro/Max)* — or — Session cost *(API key)* · Session tokens `X↓ Y↑`
 
 | Feature | Details |
 |---|---|
 | Context bar | Normalized to usable % — accounts for the auto-compact buffer |
 | Rate limits | Shows 5h and weekly usage with color-coded thresholds |
 | Session cost | Displayed only for API key users, hidden for subscribers |
-| Session tokens | Real-time token consumption via JSONL offset caching — updates between turns, not just at turn start |
+| Session tokens | Real-time via JSONL offset caching — split input/output display (`X↓ Y↑`), formatted as `k` or `M` for large counts |
 | Active agents | Counts running subagents from your `~/.claude/todos/` directory |
 | Effort level | Reads `CLAUDE_CODE_EFFORT_LEVEL` env var or `settings.json` |
 | Git branch | Detected automatically, silently absent if not a git repo |
@@ -70,7 +70,7 @@ npm picks the right one automatically. If your platform isn't listed, the JS fal
 | Subscription-aware | Shows usage/resets for Pro/Max, cost for API | Treat everyone as API user |
 | Context bar | Usable % after auto-compact buffer | Raw remaining % |
 | Subagent counter | Counts active agents from todos dir | — |
-| Session tokens | Real-time via JSONL offset cache | Stale stdin snapshot or none |
+| Session tokens | Real-time via JSONL offset cache, split I/O (`X↓ Y↑`) | Stale stdin snapshot or none |
 | Session commits | Tracks git commits made this session | — |
 
 ---

package/bin/cli.js

@@ -1,15 +1,21 @@
 #!/usr/bin/env node
 'use strict';
-const { setup } = require('../scripts/setup');
+const { setup, toggleHistory } = require('../scripts/setup');
 const { uninstall } = require('../scripts/uninstall');
-const { getSettingsPath } = require('../scripts/config');
+const config = require('../scripts/config');
+const { getSettingsPath } = config;
+const { spawnSync } = require('child_process');
+const path = require('path');
 
 const USAGE = `
 claude-statusline <command>
 
 Commands:
-  setup      Configure ~/.claude/settings.json to use this statusline
-  uninstall  Remove this statusline from ~/.claude/settings.json
+  setup            Configure ~/.claude/settings.json to use this statusline
+  uninstall        Remove this statusline from ~/.claude/settings.json
+  enable-history   Enable tracking session analytics to SQLite (default on setup)
+  disable-history  Remove history tracking hooks from Claude settings
+  history          Open the session analytics dashboard
 `.trim();
 
 const cmd = process.argv[2];
@@ -30,6 +36,36 @@ if (cmd === 'setup') {
   }
   console.log(`✓ Removed statusline from ${getSettingsPath()}`);
 
+} else if (cmd === 'enable-history') {
+  const result = toggleHistory(true);
+  if (!result.ok) {
+    console.error('Error:', result.error);
+    process.exit(1);
+  }
+  console.log(`✓ History tracking enabled in ${result.settingsPath}`);
+
+} else if (cmd === 'disable-history') {
+  const result = toggleHistory(false);
+  if (!result.ok) {
+    console.error('Error:', result.error);
+    process.exit(1);
+  }
+  console.log(`✓ History tracking disabled from ${result.settingsPath}`);
+
+} else if (cmd === 'hook' || cmd === 'history') {
+  const binaryPath = config.resolveBinary();
+  const scriptPath = path.resolve(__dirname, '../statusline.js');
+  
+  if (binaryPath) {
+    // Run Rust binary
+    const child = spawnSync(binaryPath, process.argv.slice(2), { stdio: 'inherit' });
+    process.exit(child.status || 0);
+  } else {
+    // Run JS fallback
+    const child = spawnSync(process.execPath, [scriptPath, ...process.argv.slice(2)], { stdio: 'inherit' });
+    process.exit(child.status || 0);
+  }
+
 } else if (cmd === undefined) {
   console.log(USAGE);
   process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alyibrahim/claude-statusline",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "description": "Rich statusline for Claude Code — model, context bar, real-time token tracking, git branch, rate limits, and session stats. Rust binary, ~5ms startup.",
   "keywords": [
     "claude",
@@ -39,6 +39,12 @@
     "preuninstall": "node scripts/preuninstall.js",
     "test": "jest"
   },
+  "jest": {
+    "testPathIgnorePatterns": [
+      "/node_modules/",
+      "/.worktrees/"
+    ]
+  },
   "files": [
     "statusline.js",
     "bin/",
@@ -46,12 +52,16 @@
     "README.md"
   ],
   "license": "MIT",
+  "dependencies": {
+    "open": "^10.1.0"
+  },
   "optionalDependencies": {
-    "@alyibrahim/claude-statusline-linux-x64": "1.3.1",
-    "@alyibrahim/claude-statusline-linux-arm64": "1.3.1",
-    "@alyibrahim/claude-statusline-darwin-x64": "1.3.1",
-    "@alyibrahim/claude-statusline-darwin-arm64": "1.3.1",
-    "@alyibrahim/claude-statusline-win32-x64": "1.3.1"
+    "better-sqlite3": "^11.3.0",
+    "@alyibrahim/claude-statusline-linux-x64": "1.4.0",
+    "@alyibrahim/claude-statusline-linux-arm64": "1.4.0",
+    "@alyibrahim/claude-statusline-darwin-x64": "1.4.0",
+    "@alyibrahim/claude-statusline-darwin-arm64": "1.4.0",
+    "@alyibrahim/claude-statusline-win32-x64": "1.4.0"
   },
   "devDependencies": {
     "jest": "^29.0.0"

package/scripts/history.js

@@ -0,0 +1,204 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const open = require('open');
+
+// Returns undefined if better-sqlite3 is not available
+function getDb() {
+  try {
+    const Database = require('better-sqlite3');
+    const home = process.env.HOME || process.env.USERPROFILE || '.';
+    const dbDir = path.join(home, '.claude');
+    fs.mkdirSync(dbDir, { recursive: true });
+    
+    const db = new Database(path.join(dbDir, 'statusline-history.db'));
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id TEXT UNIQUE NOT NULL,
+        project_dir TEXT NOT NULL,
+        project_name TEXT NOT NULL,
+        model TEXT NOT NULL,
+        start_time DATETIME DEFAULT CURRENT_TIMESTAMP,
+        end_time DATETIME DEFAULT CURRENT_TIMESTAMP,
+        tokens_in INTEGER DEFAULT 0,
+        tokens_out INTEGER DEFAULT 0,
+        cost_usd REAL DEFAULT 0.0,
+        duration_seconds INTEGER DEFAULT 0,
+        exit_reason TEXT 
+      )
+    `);
+    return db;
+  } catch (e) {
+    return null;
+  }
+}
+
+function handleHookStart() {
+  const db = getDb();
+  if (!db) return; // Silent fallback
+
+  const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  const projectName = path.basename(projectDir);
+  const tempSessionId = `pending-${projectName}-${Date.now()}`;
+
+  try {
+    const stmt = db.prepare('INSERT INTO sessions (session_id, project_dir, project_name, model, exit_reason) VALUES (?, ?, ?, ?, ?)');
+    stmt.run(tempSessionId, projectDir, projectName, 'pending', 'pending');
+  } catch (e) {}
+}
+
+function handleHookEnd() {
+  let input = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', chunk => input += chunk);
+  process.stdin.on('end', () => {
+    const db = getDb();
+    if (!db) return process.exit(0);
+
+    let reason = 'unknown';
+    try {
+      const data = JSON.parse(input);
+      reason = data.reason || 'unknown';
+    } catch(e) {}
+
+    const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+    const home = process.env.HOME || process.env.USERPROFILE || '.';
+    const slug = projectDir.replace(/[\/\\]/g, '-');
+    const projectsDir = path.join(home, '.claude', 'projects', slug);
+
+    let newestFile = null;
+    let newestTime = 0;
+
+    if (fs.existsSync(projectsDir)) {
+      try {
+        const files = fs.readdirSync(projectsDir);
+        for (const file of files) {
+          if (file.endsWith('.jsonl')) {
+            const p = path.join(projectsDir, file);
+            const mtime = fs.statSync(p).mtimeMs;
+            if (mtime > newestTime) {
+              newestTime = mtime;
+              newestFile = p;
+            }
+          }
+        }
+      } catch(e) {}
+    }
+
+    if (newestFile) {
+      const sessionId = path.basename(newestFile, '.jsonl');
+      let totalIn = 0;
+      let totalOut = 0;
+      let cost = 0.0;
+      let model = '';
+
+      try {
+        const content = fs.readFileSync(newestFile, 'utf8');
+        const lines = content.split('\n');
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const entry = JSON.parse(line);
+            if (entry.type === 'assistant' && entry.message?.usage) {
+              const u = entry.message.usage;
+              totalIn += (u.input_tokens || 0) + Math.round((u.cache_read_input_tokens || 0) * 0.1) + (u.cache_creation_input_tokens || 0);
+              totalOut += (u.output_tokens || 0);
+              if (!model) model = entry.message.model || 'Claude';
+            } else if (entry.type === 'cost') {
+              cost += (entry.cost_usd || 0.0);
+            } else if (entry.type === 'message_start' && !model) {
+              model = entry.message?.model || 'Claude';
+            }
+          } catch(e) {}
+        }
+      } catch(e) {}
+
+      if (!model) model = 'Claude';
+
+      try {
+        const stmt = db.prepare(`
+          UPDATE sessions 
+          SET session_id = ?, model = ?, end_time = CURRENT_TIMESTAMP, 
+              tokens_in = ?, tokens_out = ?, cost_usd = ?, exit_reason = ?,
+              duration_seconds = CAST((julianday('now') - julianday(start_time)) * 86400 as integer)
+          WHERE id = (SELECT id FROM sessions WHERE project_dir = ? AND exit_reason = 'pending' ORDER BY start_time DESC LIMIT 1)
+        `);
+        stmt.run(sessionId, model, totalIn, totalOut, cost, reason, projectDir);
+      } catch (e) {}
+    }
+    process.exit(0);
+  });
+}
+
+async function handleHistory() {
+  const db = getDb();
+  if (!db) {
+    console.error('SQLite is not available. Please install @alyibrahim/claude-statusline with native modules, or ensure better-sqlite3 is successfully installed.');
+    process.exit(1);
+  }
+
+  let html = '<!DOCTYPE html><html><head><meta charset="UTF-8"><title>Claude Statusline History</title>';
+  html += `<style>
+    body { font-family: 'Inter', sans-serif; background: #121212; color: #eee; margin: 0; padding: 40px; }
+    h1 { font-size: 24px; font-weight: 600; margin-bottom: 20px; color: #fff; }
+    .dashboard { max-width: 1000px; margin: 0 auto; }
+    .totals { display: flex; gap: 20px; margin-bottom: 30px; }
+    .card { background: #1e1e1e; padding: 20px; border-radius: 12px; flex: 1; border: 1px solid #333; }
+    .card h3 { margin: 0 0 10px 0; font-size: 14px; color: #999; text-transform: uppercase; letter-spacing: 0.5px; }
+    .card p { margin: 0; font-size: 28px; font-weight: 600; color: #fff; }
+    table { width: 100%; border-collapse: collapse; background: #1e1e1e; border-radius: 12px; overflow: hidden; border: 1px solid #333; }
+    th, td { padding: 15px; text-align: left; border-bottom: 1px solid #333; }
+    th { background: #252525; color: #aaa; font-weight: 500; font-size: 13px; text-transform: uppercase; }
+    tr:last-child td { border-bottom: none; }
+    .badge { background: #2b3a4a; color: #61afef; padding: 4px 8px; border-radius: 6px; font-size: 12px; font-weight: 600; }
+    .model { color: #98c379; }
+    .tokens { font-family: monospace; color: #e5c07b; }
+    .cost { color: #d19a66; }
+  </style></head><body>`;
+
+  html += `<div class="dashboard"><h1>Claude Statusline Analytics</h1>`;
+  
+  try {
+    const rows = db.prepare('SELECT project_name, model, start_time, duration_seconds, tokens_in, tokens_out, cost_usd, exit_reason FROM sessions ORDER BY start_time DESC LIMIT 100').all();
+    let totalCost = 0.0, totalIn = 0, totalOut = 0;
+    
+    let rowsHtml = '';
+    for (const s of rows) {
+      if (s.exit_reason !== 'pending') {
+        totalCost += (s.cost_usd || 0);
+        totalIn += (s.tokens_in || 0);
+        totalOut += (s.tokens_out || 0);
+      }
+      rowsHtml += `<tr>
+        <td><span class="badge">${s.project_name}</span></td>
+        <td class="model">${s.model}</td>
+        <td>${s.start_time}</td>
+        <td>${s.duration_seconds}s</td>
+        <td class="tokens">${s.tokens_in}↓ ${s.tokens_out}↑</td>
+        <td class="cost">$${Number(s.cost_usd).toFixed(4)}</td>
+        <td>${s.exit_reason}</td>
+      </tr>`;
+    }
+
+    html += `<div class="totals">
+      <div class="card"><h3>Total Input Tokens</h3><p>${totalIn}</p></div>
+      <div class="card"><h3>Total Output Tokens</h3><p>${totalOut}</p></div>
+      <div class="card"><h3>Total Spend</h3><p>$${totalCost.toFixed(2)}</p></div>
+    </div>`;
+
+    html += `<table><thead><tr>
+      <th>Project</th><th>Model</th><th>Start Time</th><th>Duration</th><th>Tokens</th><th>Cost</th><th>Reason</th>
+    </tr></thead><tbody>${rowsHtml}</tbody></table></div></body></html>`;
+
+    const tempPath = path.join(os.tmpdir(), 'claude-statusline-dashboard.html');
+    fs.writeFileSync(tempPath, html);
+    
+    console.log(`Opened dashboard at ${tempPath}`);
+    await open(tempPath);
+  } catch (e) {
+    console.error(`Failed to load database: ${e.message}`);
+  }
+}
+
+module.exports = { handleHookStart, handleHookEnd, handleHistory };

package/scripts/setup.js

@@ -38,6 +38,8 @@ function setup({ force = false } = {}) {
     : `"${process.execPath}" "${scriptPath}"`;
   settings.statusLine = { type: 'command', command };
 
+  updateHooks(settings, command, true);
+
   fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
 
   try {
@@ -49,4 +51,58 @@ function setup({ force = false } = {}) {
   return { ok: true, settingsPath };
 }
 
-module.exports = { setup };
+function updateHooks(settings, command, enable) {
+  if (!settings.hooks) settings.hooks = {};
+  
+  const startCmd = `${command} hook start`;
+  const endCmd = `${command} hook end`;
+
+  function toggleHook(hookName, cmdString) {
+    if (!settings.hooks[hookName]) settings.hooks[hookName] = [];
+    settings.hooks[hookName] = settings.hooks[hookName].filter(h => 
+      !(h.command && (h.command.includes('hook start') || h.command.includes('hook end')))
+    );
+    if (enable) {
+      settings.hooks[hookName].push({ type: 'command', command: cmdString });
+    }
+    if (settings.hooks[hookName].length === 0) {
+      delete settings.hooks[hookName];
+    }
+  }
+
+  toggleHook('SessionStart', startCmd);
+  toggleHook('SessionEnd', endCmd);
+
+  if (Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+}
+
+function toggleHistory(enable) {
+  const scriptPath = path.resolve(__dirname, '../statusline.js');
+  const binaryPath = config.resolveBinary();
+  const safeBinary = binaryPath && !UNSAFE_CHARS.test(binaryPath) ? binaryPath : null;
+  const command = safeBinary ? `"${safeBinary}"` : `"${process.execPath}" "${scriptPath}"`;
+
+  const settingsPath = getSettingsPath();
+  let settings = {};
+  if (fs.existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+    } catch (e) {
+      return { ok: false, error: 'settings.json contains invalid JSON — fix manually then re-run.' };
+    }
+  }
+
+  updateHooks(settings, command, enable);
+
+  try {
+    atomicWrite(settingsPath, settings);
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+
+  return { ok: true, settingsPath };
+}
+
+module.exports = { setup, toggleHistory, updateHooks };

package/scripts/uninstall.js

@@ -13,8 +13,13 @@ function uninstall() {
     return { ok: false, error: 'settings.json contains invalid JSON — cannot safely modify.' };
   }
 
-  if (!settings.statusLine) return { ok: true };
-  delete settings.statusLine;
+  if (settings.statusLine) {
+    delete settings.statusLine;
+  }
+
+  // Also strip our hooks if they exist
+  const { updateHooks } = require('./setup');
+  updateHooks(settings, '', false);
 
   try {
     atomicWrite(settingsPath, settings);

package/statusline.js

@@ -7,6 +7,21 @@ const path = require('path');
 const os = require('os');
 const { execSync, execFileSync } = require('child_process');
 
+const cmd = process.argv[2];
+if (cmd === 'history') {
+  require('./scripts/history').handleHistory();
+  return;
+} else if (cmd === 'hook') {
+  const hookcmd = process.argv[3];
+  if (hookcmd === 'start') {
+    require('./scripts/history').handleHookStart();
+    return;
+  } else if (hookcmd === 'end') {
+    require('./scripts/history').handleHookEnd();
+    return;
+  }
+}
+
 // Reads cumulative token totals from the session JSONL file, using a byte-offset
 // cache so only new bytes are parsed on each invocation (O(new bytes) not O(file)).
 // Returns { totalIn, totalOut } or null on any error.