claude-cup 0.2.0

package/src/eco.js

@@ -0,0 +1,151 @@
+// Real eco mode: makes the SAME model spend fewer tokens by toggling
+// Claude Code's own documented levers:
+//   - settings.json env:
+//       MAX_THINKING_TOKENS=4096            caps extended-thinking spend
+//       CLAUDE_CODE_MAX_OUTPUT_TOKENS=8192  caps runaway long outputs
+//       DISABLE_NON_ESSENTIAL_MODEL_CALLS=1 skips flavor/non-essential calls
+//   - ~/.claude/CLAUDE.md: a clearly-marked concise-mode instruction block
+//
+// Everything is reversible: previous values are backed up on enable and
+// restored exactly on disable. If the user hand-edits a value while eco is
+// on, disable leaves their value alone (never clobbers user intent).
+// Writes are atomic (tmp file + rename). A corrupt settings.json aborts
+// the toggle instead of overwriting it.
+import { readFileSync, writeFileSync, renameSync, existsSync, mkdirSync, unlinkSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+
+export const ECO_ENV = {
+  MAX_THINKING_TOKENS: '4096',
+  CLAUDE_CODE_MAX_OUTPUT_TOKENS: '8192',
+  DISABLE_NON_ESSENTIAL_MODEL_CALLS: '1',
+};
+
+const BLOCK_START = '<!-- claude-jar:eco:start -->';
+const BLOCK_END = '<!-- claude-jar:eco:end -->';
+const ECO_BLOCK = `${BLOCK_START}
+# Eco mode (managed by claude-jar - toggling eco off removes this block)
+Be maximally token-efficient: answer concisely with no preamble, recap, or
+celebratory summary. Read only files you truly need and never re-read
+unchanged files. Batch related edits. Prefer targeted diffs over full file
+dumps. Skip optional confirmations and pleasantries.
+${BLOCK_END}`;
+
+export const ECO_SUMMARY = 'thinking 4k \u00b7 output 8k \u00b7 trims chatter';
+
+function atomicWrite(path, content) {
+  const tmp = path + '.claude-jar-tmp';
+  writeFileSync(tmp, content);
+  renameSync(tmp, path);
+}
+
+export class EcoMode {
+  constructor({ configDir, jarDir }) {
+    this.settingsPath = join(configDir, 'settings.json');
+    this.claudeMdPath = join(configDir, 'CLAUDE.md');
+    this.statePath = join(jarDir, 'eco.json');
+  }
+
+  _readState() {
+    try {
+      return JSON.parse(readFileSync(this.statePath, 'utf8'));
+    } catch {
+      return { on: false };
+    }
+  }
+
+  _writeState(state) {
+    mkdirSync(dirname(this.statePath), { recursive: true });
+    atomicWrite(this.statePath, JSON.stringify(state, null, 2));
+  }
+
+  _readSettings() {
+    if (!existsSync(this.settingsPath)) return {};
+    const raw = readFileSync(this.settingsPath, 'utf8');
+    if (!raw.trim()) return {};
+    return JSON.parse(raw); // throws on corrupt JSON -> toggle aborts safely
+  }
+
+  /** Effective status: state flag, self-healed against manual removal. */
+  status() {
+    const state = this._readState();
+    let applied = false;
+    try {
+      const env = this._readSettings().env || {};
+      const hasEnv = Object.entries(ECO_ENV).every(([k, v]) => env[k] === v);
+      const hasBlock = existsSync(this.claudeMdPath) && readFileSync(this.claudeMdPath, 'utf8').includes(BLOCK_START);
+      applied = hasEnv || hasBlock;
+    } catch {
+      applied = false;
+    }
+    const on = Boolean(state.on && applied);
+    return { on, summary: ECO_SUMMARY, env: ECO_ENV, appliedAt: state.appliedAt || null };
+  }
+
+  enable() {
+    try {
+      const settings = this._readSettings();
+      const prevEnv = settings.env || {};
+      const backup = { env: {}, claudeMd: {} };
+      for (const key of Object.keys(ECO_ENV)) {
+        backup.env[key] = Object.prototype.hasOwnProperty.call(prevEnv, key) ? prevEnv[key] : null;
+      }
+      settings.env = { ...prevEnv, ...ECO_ENV };
+      atomicWrite(this.settingsPath, JSON.stringify(settings, null, 2) + '\n');
+
+      const mdExisted = existsSync(this.claudeMdPath);
+      backup.claudeMd.existed = mdExisted;
+      const md = mdExisted ? readFileSync(this.claudeMdPath, 'utf8') : '';
+      if (!md.includes(BLOCK_START)) {
+        const next = md.trim() ? `${md.replace(/\s+$/, '')}\n\n${ECO_BLOCK}\n` : `${ECO_BLOCK}\n`;
+        atomicWrite(this.claudeMdPath, next);
+      }
+
+      this._writeState({ on: true, appliedAt: Date.now(), backup });
+      return { ok: true, status: this.status() };
+    } catch (err) {
+      return { ok: false, error: `could not enable eco mode: ${err.message}`, status: this.status() };
+    }
+  }
+
+  disable() {
+    try {
+      const state = this._readState();
+      const backup = state.backup || { env: {}, claudeMd: {} };
+
+      const settings = this._readSettings();
+      if (settings.env) {
+        for (const [key, ecoValue] of Object.entries(ECO_ENV)) {
+          // only undo values we set; leave the user's manual edits alone
+          if (settings.env[key] === ecoValue) {
+            const prev = backup.env?.[key];
+            if (prev === null || prev === undefined) delete settings.env[key];
+            else settings.env[key] = prev;
+          }
+        }
+        if (Object.keys(settings.env).length === 0) delete settings.env;
+        atomicWrite(this.settingsPath, JSON.stringify(settings, null, 2) + '\n');
+      }
+
+      if (existsSync(this.claudeMdPath)) {
+        const md = readFileSync(this.claudeMdPath, 'utf8');
+        const startIdx = md.indexOf(BLOCK_START);
+        const endIdx = md.indexOf(BLOCK_END);
+        if (startIdx !== -1 && endIdx !== -1) {
+          const before = md.slice(0, startIdx).replace(/\n+$/, '\n');
+          const after = md.slice(endIdx + BLOCK_END.length).replace(/^\n+/, '');
+          const next = (before + after).replace(/^\n+/, '').replace(/\s+$/, '');
+          if (!next && backup.claudeMd?.existed === false) {
+            unlinkSync(this.claudeMdPath); // we created the file; remove it again
+          } else {
+            atomicWrite(this.claudeMdPath, next ? next + '\n' : '');
+          }
+        }
+      }
+
+      this._writeState({ on: false });
+      return { ok: true, status: this.status() };
+    } catch (err) {
+      return { ok: false, error: `could not disable eco mode: ${err.message}`, status: this.status() };
+    }
+  }
+}

package/src/parse.js

@@ -0,0 +1,86 @@
+// Parses one line of a Claude Code JSONL transcript into a compact event, or null.
+
+const CATEGORY_BY_TOOL = {
+  read: ['Read', 'Glob', 'Grep', 'LS', 'NotebookRead', 'ListMcpResourcesTool', 'ReadMcpResourceTool'],
+  edit: ['Edit', 'Write', 'MultiEdit', 'NotebookEdit', 'StrReplace', 'Delete'],
+  terminal: ['Bash', 'BashOutput', 'KillShell', 'Shell', 'AwaitShell'],
+  web: ['WebSearch', 'WebFetch'],
+  agent: ['Task', 'Agent'],
+};
+
+const toolToCategory = new Map();
+for (const [cat, names] of Object.entries(CATEGORY_BY_TOOL)) {
+  for (const n of names) toolToCategory.set(n.toLowerCase(), cat);
+}
+
+export function categorizeTool(name) {
+  if (!name) return 'other';
+  const found = toolToCategory.get(String(name).toLowerCase());
+  if (found) return found;
+  if (/^mcp__/i.test(name)) return 'web';
+  return 'other';
+}
+
+function num(v) {
+  return typeof v === 'number' && Number.isFinite(v) ? v : 0;
+}
+
+/**
+ * @param {string} line raw JSONL line
+ * @returns {object|null} event:
+ *   { kind:'assistant', uuid, sessionId, ts, model, usage:{in,out,cacheRead,cacheW5m,cacheW1h}, tools:[{name,category}] }
+ *   { kind:'prompt', uuid, sessionId, ts }
+ */
+export function parseLine(line) {
+  if (!line) return null;
+  // strip BOM and CR
+  let s = line.replace(/^\uFEFF/, '').trim();
+  if (!s) return null;
+  let obj;
+  try {
+    obj = JSON.parse(s);
+  } catch {
+    return null;
+  }
+  if (!obj || typeof obj !== 'object') return null;
+
+  const ts = obj.timestamp ? Date.parse(obj.timestamp) : NaN;
+  if (!Number.isFinite(ts)) return null;
+  const base = { uuid: obj.uuid || null, sessionId: obj.sessionId || null, ts };
+
+  if (obj.type === 'assistant' && obj.message) {
+    const m = obj.message;
+    const u = m.usage || {};
+    const cc = u.cache_creation || {};
+    const tools = [];
+    if (Array.isArray(m.content)) {
+      for (const block of m.content) {
+        if (block && block.type === 'tool_use') {
+          tools.push({ name: block.name || 'unknown', category: categorizeTool(block.name) });
+        }
+      }
+    }
+    return {
+      kind: 'assistant',
+      ...base,
+      model: m.model || 'unknown',
+      usage: {
+        in: num(u.input_tokens),
+        out: num(u.output_tokens),
+        cacheRead: num(u.cache_read_input_tokens),
+        cacheW5m: num(cc.ephemeral_5m_input_tokens) || (cc.ephemeral_1h_input_tokens == null ? num(u.cache_creation_input_tokens) : 0),
+        cacheW1h: num(cc.ephemeral_1h_input_tokens),
+      },
+      tools,
+    };
+  }
+
+  if (obj.type === 'user' && obj.message && !obj.isMeta) {
+    // Skip tool_result carriers; count only real human prompts.
+    const c = obj.message.content;
+    const isToolResult = Array.isArray(c) && c.some((b) => b && b.type === 'tool_result');
+    if (!isToolResult) return { kind: 'prompt', ...base };
+  }
+
+  return null;
+}

package/src/server.js

@@ -0,0 +1,162 @@
+// Localhost-only HTTP server: static UI + SSE event stream + JSON state.
+import { createServer } from 'node:http';
+import { readFile } from 'node:fs/promises';
+import { join, extname, normalize } from 'node:path';
+
+const MIME = {
+  '.html': 'text/html; charset=utf-8',
+  '.js': 'text/javascript; charset=utf-8',
+  '.css': 'text/css; charset=utf-8',
+  '.svg': 'image/svg+xml',
+  '.png': 'image/png',
+  '.json': 'application/json',
+};
+
+export function createJarServer({ distDir, aggregator, poller, watcher, eco, dbh }) {
+  const clients = new Set();
+  let statsDirty = false;
+
+  function broadcast(event, data) {
+    const msg = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+    for (const res of clients) res.write(msg);
+  }
+
+  function fullState() {
+    return {
+      stats: aggregator.snapshot(),
+      usage: poller.state,
+      history: aggregator.historyDays(7),
+      eco: eco ? eco.status() : null,
+      serverTime: Date.now(),
+    };
+  }
+
+  // Wiring: transcripts -> aggregator -> (live) activity events to browser
+  watcher.on('event', (evt, { live }) => {
+    const counted = aggregator.addEvent(evt);
+    if (!counted || !live) return;
+    statsDirty = true;
+    if (evt.kind === 'assistant') {
+      const freshTokens = evt.usage.in + evt.usage.out;
+      broadcast('activity', {
+        kind: 'message',
+        category: 'ai',
+        model: evt.model,
+        tokens: freshTokens,
+        ts: evt.ts,
+      });
+      for (const t of evt.tools) {
+        broadcast('activity', { kind: 'tool', category: t.category, name: t.name, ts: evt.ts });
+      }
+    }
+  });
+
+  poller.on('usage', (usage) => {
+    if (usage.status === 'ok' && usage.fiveHour) aggregator.noteFill(usage.fiveHour.pct);
+    broadcast('usage', usage);
+  });
+
+  const statsTimer = setInterval(() => {
+    if (statsDirty && clients.size) {
+      statsDirty = false;
+      broadcast('stats', aggregator.snapshot());
+    }
+  }, 2000);
+  statsTimer.unref?.();
+
+  const heartbeat = setInterval(() => {
+    for (const res of clients) res.write(': ping\n\n');
+  }, 25_000);
+  heartbeat.unref?.();
+
+  const server = createServer(async (req, res) => {
+    const url = new URL(req.url, 'http://localhost');
+    const path = url.pathname;
+
+    if (path === '/events') {
+      res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        Connection: 'keep-alive',
+      });
+      res.write(`event: snapshot\ndata: ${JSON.stringify(fullState())}\n\n`);
+      clients.add(res);
+      req.on('close', () => clients.delete(res));
+      return;
+    }
+
+    if (path === '/api/state') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(fullState()));
+      return;
+    }
+
+    if (path === '/api/mcp-state' && dbh) {
+      try {
+        const { getCurrentSession, getRecentActivity, getValidatedTokenSummary } = await import('../mcp-server/src/db.js');
+        const sess = getCurrentSession(dbh) || {};
+        const recent = getRecentActivity(dbh, 20);
+        const tokenSummary = getValidatedTokenSummary(dbh);
+        const mcpState = {
+          session_id: sess.session_id || null,
+          total_intensity: sess.total_intensity || 0,
+          environment_richness_score: sess.environment_richness_score || 0,
+          power_level: sess.power_level || 'standard',
+          recent_event_count: recent.length,
+          token_summary: tokenSummary,
+          last_update_ts: sess.last_update_ts || null,
+        };
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(mcpState));
+      } catch (e) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: e.message }));
+      }
+      return;
+    }
+
+    if (path === '/api/eco' && eco) {
+      if (req.method === 'POST') {
+        let body = '';
+        req.on('data', (d) => (body += d));
+        req.on('end', () => {
+          let result;
+          try {
+            const want = Boolean(JSON.parse(body || '{}').on);
+            result = want ? eco.enable() : eco.disable();
+          } catch (err) {
+            result = { ok: false, error: err.message, status: eco.status() };
+          }
+          broadcast('eco', eco.status());
+          res.writeHead(result.ok ? 200 : 500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify(result));
+        });
+      } else {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(eco.status()));
+      }
+      return;
+    }
+
+    // static files
+    const rel = path === '/' ? 'index.html' : path.slice(1);
+    const file = normalize(join(distDir, rel));
+    if (!file.startsWith(normalize(distDir))) {
+      res.writeHead(403).end();
+      return;
+    }
+    try {
+      const body = await readFile(file);
+      res.writeHead(200, {
+        'Content-Type': MIME[extname(file)] || 'application/octet-stream',
+        'Cache-Control': 'no-cache',
+      });
+      res.end(body);
+    } catch {
+      res.writeHead(404, { 'Content-Type': 'text/plain' });
+      res.end('not found');
+    }
+  });
+
+  return { server, broadcast, clientCount: () => clients.size };
+}

package/src/statusline.js

@@ -0,0 +1,71 @@
+// `claude-jar statusline`: one-line jar meter for Claude Code's statusline.
+// Claude Code (>= 2.1.80) pipes session JSON to the statusline command on
+// stdin, including rate_limits for Pro/Max accounts. We parse it and print
+// a single line. No network calls - this runs on every statusline refresh.
+//
+// Glyph language matches Claude Code itself: the ✻ spark, █░ meter,
+// dim · separators. No emoji (renders everywhere, including conhost).
+
+const CLAY = '\x1b[38;2;217;119;87m';
+const EMBER = '\x1b[38;2;198;97;63m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const RESET = '\x1b[0m';
+const SPARK = '\u273b'; // ✻
+
+// All known fields are percentages (used_percentage 42 = 42%, utilization 1 = 1%).
+function pctOf(bucket) {
+  if (!bucket || typeof bucket !== 'object') return null;
+  const v = bucket.used_percentage ?? bucket.utilization ?? bucket.percent;
+  if (typeof v !== 'number' || !Number.isFinite(v)) return null;
+  return Math.max(0, Math.min(100, v));
+}
+
+function countdown(resetsAt) {
+  if (!resetsAt) return null;
+  const ms = Date.parse(resetsAt) - Date.now();
+  if (!Number.isFinite(ms) || ms <= 0) return null;
+  const h = Math.floor(ms / 3600000);
+  const m = Math.floor((ms % 3600000) / 60000);
+  return h > 0 ? `${h}h${m}m` : `${m}m`;
+}
+
+/** Pure formatter (exported for tests). Returns the statusline string. */
+export function formatStatusline(input) {
+  const rl = input?.rate_limits || {};
+  const five = pctOf(rl.five_hour);
+  const seven = pctOf(rl.seven_day);
+
+  if (five === null && seven === null) {
+    return `${CLAY}${SPARK}${RESET} ${DIM}claude-jar${RESET}`;
+  }
+
+  const parts = [];
+  if (five !== null) {
+    const slots = 8;
+    const filled = Math.round((five / 100) * slots);
+    const color = five > 85 ? EMBER : CLAY;
+    const bar =
+      `${color}${'\u2588'.repeat(filled)}${RESET}` + `${DIM}${'\u2591'.repeat(slots - filled)}${RESET}`;
+    parts.push(`${color}${SPARK}${RESET} ${bar} ${BOLD}${Math.round(five)}%${RESET}`);
+    const reset = countdown(rl.five_hour?.resets_at);
+    if (reset) parts.push(`${DIM}\u21bb ${reset}${RESET}`);
+  }
+  if (seven !== null) {
+    const sevenStr = seven > 85 ? `${EMBER}${Math.round(seven)}%${RESET}` : `${Math.round(seven)}%`;
+    parts.push(`${DIM}7d${RESET} ${sevenStr}`);
+  }
+  return parts.join(` ${DIM}\u00b7${RESET} `);
+}
+
+export async function runStatusline() {
+  let raw = '';
+  for await (const chunk of process.stdin) raw += chunk;
+  let input = null;
+  try {
+    input = JSON.parse(raw);
+  } catch {
+    /* no/bad input: print the idle form */
+  }
+  process.stdout.write(formatStatusline(input) + '\n');
+}