@weavecode/weave 0.1.1 → 0.1.2

package/node_modules/@weavecode/harness/dist/claude/statusline/generator.js

@@ -0,0 +1,745 @@
+import{CONTEXT_STYLE_FORMAT as c,POWERLINE_DEFAULT_GLYPHS as e,SEGMENT_DEFAULT_FORMAT as d,SEGMENT_ORDER as p}from"./config.js";const h={gray:"90",red:"31",green:"32",yellow:"33",blue:"34",magenta:"35",cyan:"36"},f={gray:"100",red:"41",green:"42",yellow:"43",blue:"44",magenta:"45",cyan:"46"},g="\u2588",m="\u2591",v=10,E=8*1024*1024,r=5e3,y=3600,F=60,b=60,w=60,C=5;export function generateStatuslineScript(n,t){const u=JSON.stringify(n),i=JSON.stringify(t.cacheDir),s=JSON.stringify(h),a=JSON.stringify(f),o=JSON.stringify(d),l=JSON.stringify(c);return`#!/usr/bin/env node
+/**
+ * weave statusline \u2014 generated by the weave dashboard.
+ * Reads Claude Code's statusline JSON from stdin and prints a summary.
+ * Generated by weave \u2014 do not edit manually.
+ * @version weave@0.1.0
+ */
+'use strict';
+
+const CONFIG = ${u};
+const ANSI = ${s};
+const BG = ${a};
+const SEGMENT_FORMAT = ${o};
+const CONTEXT_FORMAT = ${l};
+const BAR_FILL = '${g}';
+const BAR_EMPTY = '${m}';
+const BAR_CELLS = ${v};
+const GIT_IDENTITY_TTL = ${y};
+const GIT_CHANGES_TTL = ${F};
+const GIT_BRANCH_TTL = ${b};
+const GIT_SYNC_TTL = ${w};
+const GIT_RETRY_TTL = ${C};
+const CACHE_DIR = ${i};
+// Stamped into the row-0 logo so the running version is always visible.
+const WEAVE_VERSION = ${JSON.stringify(t.version)};
+// Powerline glyphs (Nerd Font), configurable via CONFIG.powerline: undefined
+// falls back to the classic triangle set; an empty cap string disables the cap.
+const PL = CONFIG.powerline || {};
+const GLYPH_JOIN = PL.separator === undefined ? ${JSON.stringify(e.separator)} : PL.separator;
+const GLYPH_START = PL.startCap === undefined ? ${JSON.stringify(e.startCap)} : PL.startCap;
+const GLYPH_END = PL.endCap === undefined ? ${JSON.stringify(e.endCap)} : PL.endCap;
+
+// --- colour encoding -------------------------------------------------------
+// A colour is a named ANSI colour ('red'), an indexed value ('ansi256:196') or
+// truecolor hex ('#rrggbb' / '#rgb'). Anything unrecognised degrades to white
+// (fg) or no background rather than emitting a broken escape sequence.
+
+function hexToRgb(color) {
+  var six = /^#([0-9a-fA-F]{6})$/.exec(color);
+  if (six) {
+    var s = six[1];
+    return [parseInt(s.slice(0, 2), 16), parseInt(s.slice(2, 4), 16), parseInt(s.slice(4, 6), 16)];
+  }
+  var three = /^#([0-9a-fA-F]{3})$/.exec(color);
+  if (three) {
+    var t = three[1];
+    return [parseInt(t[0] + t[0], 16), parseInt(t[1] + t[1], 16), parseInt(t[2] + t[2], 16)];
+  }
+  return null;
+}
+
+function indexed(color) {
+  var m = /^ansi256:(\\d{1,3})$/.exec(color);
+  if (!m) return null;
+  var n = Number(m[1]);
+  return n >= 0 && n <= 255 ? n : null;
+}
+
+function fgCode(color) {
+  if (!color) return '39';
+  if (ANSI[color]) return ANSI[color];
+  var n = indexed(color);
+  if (n !== null) return '38;5;' + n;
+  var rgb = hexToRgb(color);
+  if (rgb) return '38;2;' + rgb[0] + ';' + rgb[1] + ';' + rgb[2];
+  return '37';
+}
+
+function bgCode(color) {
+  if (!color) return null;
+  if (BG[color]) return BG[color];
+  var n = indexed(color);
+  if (n !== null) return '48;5;' + n;
+  var rgb = hexToRgb(color);
+  if (rgb) return '48;2;' + rgb[0] + ';' + rgb[1] + ';' + rgb[2];
+  return null;
+}
+
+function paint(text, color, bold, bg) {
+  var fg = fgCode(color);
+  var prefix = bold ? '1;' : '';
+  var b = bgCode(bg);
+  return '\\x1b[' + prefix + fg + (b ? ';' + b : '') + 'm' + text + '\\x1b[0m';
+}
+
+function dim(text) {
+  return '\\x1b[2;90m' + text + '\\x1b[0m';
+}
+
+// --- render cache -----------------------------------------------------------
+// Every render is a fresh process, so the file \u2014 not the process \u2014 is what
+// carries the transcript scan across renders. One file per session under
+// CACHE_DIR; the git segments do NOT live here (see GIT_FILE below) because
+// they describe the worktree rather than the session. The daemon's sweeper
+// drops expired entries and files of sessions that stopped rendering.
+//
+// Top level on purpose: flush() below writes it after main() returns, so a
+// render that throws half-way still keeps what it had already scanned.
+var CACHE_FILE = null;
+var CACHE = null;
+// \u53EA\u5728\u771F\u6709\u6761\u76EE\u843D\u5B9A\u65F6\u624D\u56DE\u5199\uFF1A\u7EAF\u547D\u4E2D\u7684\u6E32\u67D3\u96F6\u5199\u76D8\uFF08\u65E7\u5B9E\u73B0\u540C\u6837\u53EA\u5728\u672A\u547D\u4E2D\u65F6\u5199\uFF09\u3002
+var CACHE_DIRTY = false;
+
+// Git \u6BB5\u63CF\u8FF0\u7684\u662F\u5DE5\u4F5C\u533A\uFF0C\u4E0D\u662F\u4F1A\u8BDD\uFF1A\u540C\u4E00\u9879\u76EE\u7684\u6BCF\u4E2A\u4F1A\u8BDD\u90FD\u5728\u95EE\u540C\u4E00\u4E2A\u95EE\u9898\u3002\u6240\u4EE5
+// \u5B83\u53E6\u5B58\u4E00\u4EFD\u6309\u76EE\u5F55\u5206\u7247\u7684\u6587\u4EF6\uFF08git-<cwd \u6458\u8981>.json\uFF09\uFF0C\u5404\u4F1A\u8BDD\u5171\u4EAB\u2014\u2014\u4E00\u4E2A TTL \u5185
+// \u6574\u4E2A\u9879\u76EE\u53EA\u4ED8\u4E00\u6B21 git \u5B50\u8FDB\u7A0B\uFF0C\u6709\u591A\u5C11\u4F1A\u8BDD\u5728\u6E32\u67D3\u90FD\u4E00\u6837\u3002\u6761\u76EE\u952E\u56E0\u6B64\u53EA\u662F
+// branch / git_user / changes \u4E09\u6837\uFF0C\u4E0D\u5E26\u76EE\u5F55\uFF08\u76EE\u5F55\u5DF2\u7ECF\u662F\u6587\u4EF6\u540D\u4E86\uFF09\u3002\u5E76\u53D1\u5199\u7528\u540C\u4E00\u5957
+// tmp+rename\uFF0C\u540E\u5199\u7684\u6574\u4EFD\u8986\u76D6\u5148\u5199\u7684\uFF08\u4E22\u4E00\u6761\u8FC7\u671F\u6761\u76EE\u53EA\u4F1A\u8BA9\u4E0B\u6B21\u91CD\u63A2\u4E00\u6B21\uFF09\u3002
+var GIT_FILE = null;
+var GIT_CACHE = null;
+var GIT_DIRTY = false;
+
+// Session key: Claude Code's session id, then the transcript basename, then a
+// cwd digest for hosts that send neither.
+function cacheKeyOf(input) {
+  var path = require('path');
+  var raw = (input.session_id != null && String(input.session_id))
+    || (typeof input.transcript_path === 'string'
+      ? path.basename(input.transcript_path, '.jsonl')
+      : '');
+  if (raw) return raw.replace(/[^A-Za-z0-9._-]+/g, '_').slice(0, 64) || 'session';
+  var crypto = require('crypto');
+  var cwd = (input.workspace && input.workspace.current_dir) || process.cwd();
+  return crypto.createHash('sha1').update(cwd).digest('hex').slice(0, 16);
+}
+
+function initCache(input) {
+  var path = require('path');
+  var crypto = require('crypto');
+  CACHE_FILE = path.join(CACHE_DIR, cacheKeyOf(input) + '.json');
+  var cwd = (input.workspace && input.workspace.current_dir) || process.cwd();
+  // \u4E00\u4E2A\u76EE\u5F55\u4E00\u4E2A\u6587\u4EF6\uFF1A\u5927\u5C0F\u5199\u4E0D\u654F\u611F\uFF08Windows\uFF09\uFF0C\u5206\u9694\u7B26\u4E0E\u5C3E\u659C\u6760\u7684\u4E0D\u540C\u5199\u6CD5\u4E5F\u7B97\u540C\u4E00\u4E2A
+  var dirKey = crypto.createHash('sha1')
+    .update(String(cwd).toLowerCase().replace(/\\\\/g, '/').replace(/\\/+$/, ''))
+    .digest('hex').slice(0, 16);
+  GIT_FILE = path.join(CACHE_DIR, 'git-' + dirKey + '.json');
+}
+
+// Lazily read once per render: a render that touches no cached segment must not
+// create a file at all.
+function cache() {
+  if (CACHE) return CACHE;
+  var fs = require('fs');
+  var loaded = null;
+  try { loaded = JSON.parse(fs.readFileSync(CACHE_FILE, 'utf8')); } catch (e) {}
+  CACHE = loaded && typeof loaded === 'object' ? loaded : {};
+  CACHE.v = 1;
+  if (!CACHE.tokens || typeof CACHE.tokens !== 'object') CACHE.tokens = {};
+  return CACHE;
+}
+
+// \u5F62\u72B6\u4E0E sweeper \u7684\u5224\u636E\u4E00\u81F4\uFF08git \u6761\u76EE + tokens\uFF09\uFF0C\u5171\u4EAB\u6587\u4EF6\u56E0\u6B64\u4E0D\u5FC5\u53E6\u7ACB\u56DE\u6536\u89C4\u5219\uFF1A
+// \u6761\u76EE\u5168\u90E8\u8FC7\u671F\u65F6\u5B83\u6309\u300C\u4E24\u680F\u90FD\u7A7A\u300D\u628A\u6587\u4EF6\u5220\u6389\u3002
+function gitCache() {
+  if (GIT_CACHE) return GIT_CACHE;
+  var fs = require('fs');
+  var loaded = null;
+  try { loaded = JSON.parse(fs.readFileSync(GIT_FILE, 'utf8')); } catch (e) {}
+  GIT_CACHE = loaded && typeof loaded === 'object' ? loaded : {};
+  GIT_CACHE.v = 1;
+  if (!GIT_CACHE.git || typeof GIT_CACHE.git !== 'object') GIT_CACHE.git = {};
+  return GIT_CACHE;
+}
+
+function writeCacheFile(file, data) {
+  var fs = require('fs');
+  var path = require('path');
+  data.updatedAt = Date.now();
+  var tmp = file + '.' + process.pid + '.tmp';
+  var payload = JSON.stringify(data);
+  // atomic replace: renders overlap while Claude Code re-runs on a debounce
+  function put() { fs.writeFileSync(tmp, payload); fs.renameSync(tmp, file); }
+  try {
+    put();
+  } catch (e) {
+    // steady state the directory is already there \u2014 pay mkdir only when it is not
+    try { fs.mkdirSync(path.dirname(file), { recursive: true }); put(); } catch (e2) {}
+  }
+}
+
+function flushCache() {
+  if (!CACHE || !CACHE_FILE || !CACHE_DIRTY) return;
+  writeCacheFile(CACHE_FILE, CACHE);
+}
+
+function flushGitCache() {
+  if (!GIT_CACHE || !GIT_FILE || !GIT_DIRTY) return;
+  writeCacheFile(GIT_FILE, GIT_CACHE);
+}
+
+// Git-derived segments cost a subprocess each, and Claude Code re-invokes us far
+// more often than the value changes. A failed lookup \u2014 not a repo, git missing
+// from PATH \u2014 is cached too, so a directory that never has git stops being
+// re-probed on every render; but only for the short retry window, since holding
+// a failure for an identity's full TTL would hide the segment for an hour.
+function cachedGit(key, ttlSec, produce) {
+  var now = Date.now();
+  var store = gitCache();
+  var hit = store.git[key];
+  if (hit && hit.expires > now) return hit.value;
+  var value = produce();
+  var ttl = value == null ? Math.min(ttlSec, GIT_RETRY_TTL) : ttlSec;
+  store.git[key] = { expires: now + ttl * 1000, value: value };
+  GIT_DIRTY = true;
+  return value;
+}
+
+function main(raw) {
+var input = {};
+try { input = JSON.parse(raw || ''); } catch (e) {}
+
+var cwd = (input.workspace && input.workspace.current_dir) || process.cwd();
+var path = require('path');
+initCache(input);
+
+// Normalise a used-percentage from Claude Code: value may be 0-100 or a 0-1 fraction.
+function pctOf(value) {
+  if (value == null || isNaN(value)) return null;
+  var p = Number(value);
+  if (p <= 1 && p > 0) p = p * 100;
+  return Math.max(0, Math.min(100, Math.round(p)));
+}
+
+// Compact a token count: 1000000 -> '1.0M', 12000 -> '12k', 960900 -> '960.9k'.
+// M keeps one decimal (matching how context windows are quoted); k drops a
+// trailing '.0' so whole thousands read as '12k' rather than '12.0k'.
+function humanize(n) {
+  if (n == null || isNaN(n)) return '';
+  var v = Number(n);
+  if (v >= 1e6) return (v / 1e6).toFixed(1) + 'M';
+  if (v >= 1e3) return (v / 1e3).toFixed(1).replace(/\\.0$/, '') + 'k';
+  return String(Math.round(v));
+}
+
+// Milliseconds to a compact duration: 45s / 12m / 2.5h / 3d. Empty when the
+// value is missing so an absent token renders as nothing.
+function humanizeMs(ms) {
+  if (ms == null || isNaN(ms) || Number(ms) <= 0) return '';
+  var sec = Number(ms) / 1000;
+  if (sec < 60) return Math.round(sec) + 's';
+  if (sec < 3600) return (sec / 60).toFixed(1).replace(/\\.0$/, '') + 'm';
+  if (sec < 86400) return (sec / 3600).toFixed(1).replace(/\\.0$/, '') + 'h';
+  return (sec / 86400).toFixed(1).replace(/\\.0$/, '') + 'd';
+}
+
+// Render a progress bar of CONFIG.bar.cells cells from a 0-100 percentage.
+function barFor(pct, bar) {
+  var cells = Math.max(1, Math.min(40, (bar && bar.cells) || BAR_CELLS));
+  var fill = (bar && bar.fill) || BAR_FILL;
+  var empty = (bar && bar.empty) || BAR_EMPTY;
+  var filled = Math.round((pct / 100) * cells);
+  // A non-zero percentage must light at least one cell: with 12 cells even 4%
+  // rounds down to 0 and the bar reads as completely empty next to "(4%)".
+  if (pct > 0 && filled === 0) filled = 1;
+  return new Array(filled + 1).join(fill) + new Array(cells - filled + 1).join(empty);
+}
+
+// Substitute {token} placeholders; an absent token renders as nothing rather
+// than the string 'undefined'.
+function applyFormat(tokens, format) {
+  return String(format).replace(/\\{(\\w+)\\}/g, function (_m, key) {
+    return tokens[key] === undefined || tokens[key] === null ? '' : String(tokens[key]);
+  });
+}
+
+// --- data sources ----------------------------------------------------------
+
+// Added/deleted line counts against HEAD. execFile (not exec) so no shell is
+// involved \u2014 the old implementation shelled out to a cmd.exe-only 'find /c'
+// that always failed on POSIX.
+function parseNumstat(out) {
+  var added = 0, deleted = 0, files = 0;
+  var rows = out.split('\\n');
+  for (var i = 0; i < rows.length; i++) {
+    if (!rows[i]) continue;
+    var p = rows[i].split('\\t');
+    if (p.length < 3) continue;
+    files++;
+    // binary files report '-' instead of a line count
+    if (p[0] !== '-') added += parseInt(p[0], 10) || 0;
+    if (p[1] !== '-') deleted += parseInt(p[1], 10) || 0;
+  }
+  return { added: added, deleted: deleted, files: files };
+}
+
+function gitNumstat(dir) {
+  var cp = require('child_process');
+  var attempts = [
+    ['--no-optional-locks', 'diff', 'HEAD', '--numstat'],
+    ['--no-optional-locks', 'diff', '--numstat'],
+  ];
+  for (var i = 0; i < attempts.length; i++) {
+    try {
+      return parseNumstat(cp.execFileSync('git', attempts[i], {
+        cwd: dir, stdio: ['ignore', 'pipe', 'ignore'], timeout: 3000, windowsHide: true,
+      }).toString());
+    } catch (e) { /* unborn HEAD, or not a repo \u2014 try the next form */ }
+  }
+  return null;
+}
+
+// Commits the branch is ahead of / behind its upstream. A branch without an
+// upstream (or a plain directory) just has no sync hint \u2014 not an error, so it
+// caches as null and the token renders empty.
+function gitAheadBehind(dir) {
+  try {
+    var out = require('child_process').execFileSync(
+      'git', ['rev-list', '--left-right', '--count', 'HEAD...@{upstream}'],
+      { cwd: dir, stdio: ['ignore', 'pipe', 'ignore'], timeout: 3000, windowsHide: true }
+    ).toString().trim();
+    var p = out.split(/\\s+/);
+    var ahead = parseInt(p[0], 10) || 0;
+    var behind = parseInt(p[1], 10) || 0;
+    if (!ahead && !behind) return null;
+    // behind first: the down arrow is "to pull", the up arrow is "to push"
+    var parts = [];
+    if (behind) parts.push(behind + '\u2193');
+    if (ahead) parts.push(ahead + '\u2191');
+    return { ahead: String(ahead), behind: String(behind), sync: '(' + parts.join('/') + ')' };
+  } catch (e) { return null; }
+}
+
+// One git config value. 'git config <key>' resolves precedence itself (repo
+// config overrides the global one), so this always yields the EFFECTIVE value.
+function gitConfigValue(dir, key) {
+  try {
+    return require('child_process').execFileSync('git', ['config', key], {
+      cwd: dir, stdio: ['ignore', 'pipe', 'ignore'], timeout: 3000, windowsHide: true,
+    }).toString().trim();
+  } catch (e) { return ''; }
+}
+
+// Cumulative session tokens, read from the transcript Claude Code points us at.
+//
+// The scan is incremental: a tokens entry keyed by transcript path records how
+// many bytes have been consumed and the running total, so steady-state renders
+// read only the newly appended tail. The same assistant message is written once
+// per content block (measured: 73 usage records for 26 distinct messages in one
+// real session), so records are de-duplicated by message id \u2014 without that the
+// total reads roughly three times too high.
+function sessionTokens(transcriptPath) {
+  if (!transcriptPath) return null;
+  var fs = require('fs');
+  var stat;
+  try { stat = fs.statSync(transcriptPath); } catch (e) { return null; }
+  if (!stat.size) return null;
+
+  var store = cache();
+  var entry = store.tokens[transcriptPath];
+  if (!entry || typeof entry.offset !== 'number' || typeof entry.total !== 'number' || !Array.isArray(entry.ids)) {
+    entry = { offset: 0, total: 0, ids: [] };
+  }
+  // a shorter file means it was truncated or rewritten (/compact) \u2014 start over
+  if (stat.size < entry.offset) entry = { offset: 0, total: 0, ids: [] };
+  store.tokens[transcriptPath] = entry;
+  if (stat.size === entry.offset) return entry.total || null;
+
+  var len = Math.min(stat.size - entry.offset, ${E});
+  var buf = Buffer.alloc(len);
+  var read = 0;
+  var fd = -1;
+  try {
+    fd = fs.openSync(transcriptPath, 'r');
+    read = fs.readSync(fd, buf, 0, len, entry.offset);
+  } catch (e) {
+    return entry.total || null;
+  } finally {
+    if (fd >= 0) { try { fs.closeSync(fd); } catch (e) {} }
+  }
+
+  var chunk = buf.slice(0, read).toString('utf8');
+  var lastNewline = chunk.lastIndexOf('\\n');
+  // no complete line yet (or the tail is mid-write) \u2014 leave it for the next run
+  if (lastNewline < 0) return entry.total || null;
+  var consumed = lastNewline + 1;
+
+  var seen = {};
+  for (var s = 0; s < entry.ids.length; s++) seen[entry.ids[s]] = true;
+  var lines = chunk.slice(0, consumed).split('\\n');
+  for (var i = 0; i < lines.length; i++) {
+    if (!lines[i]) continue;
+    var rec;
+    try { rec = JSON.parse(lines[i]); } catch (e) { continue; }
+    var msg = rec && rec.message;
+    var usage = msg && msg.usage;
+    if (!usage) continue;
+    var id = msg.id || (rec && rec.uuid);
+    if (!id || seen[id]) continue;
+    seen[id] = true;
+    entry.ids.push(id);
+    entry.total += (usage.input_tokens || 0) + (usage.output_tokens || 0)
+      + (usage.cache_read_input_tokens || 0) + (usage.cache_creation_input_tokens || 0);
+  }
+  entry.offset += consumed;
+  if (entry.ids.length > ${r}) {
+    entry.ids = entry.ids.slice(entry.ids.length - ${r});
+  }
+  CACHE_DIRTY = true;
+  return entry.total || null;
+}
+
+// Tokens in the context window: prefer the component breakdown, then the
+// session's input/output totals, then derive from the percentage.
+function contextUsed(cw, total, pct) {
+  var cu = cw.current_usage;
+  if (cu) {
+    var sum = (cu.input_tokens || 0) + (cu.output_tokens || 0)
+      + (cu.cache_read_input_tokens || 0) + (cu.cache_creation_input_tokens || 0);
+    if (sum > 0) return sum;
+  }
+  if (cw.total_input_tokens != null) {
+    return cw.total_input_tokens + (cw.total_output_tokens || 0);
+  }
+  return Math.round((pct / 100) * (total || 0));
+}
+
+// Resolve a segment to its format tokens. null means "no data" \u2014 the segment is
+// dropped from the line rather than rendering an empty shell.
+function segmentTokens(key, seg) {
+  switch (key) {
+    case 'project': {
+      // {name} is the directory basename, {path} the full working directory \u2014
+      // the latter is what the reference layout shows.
+      var name = path.basename(cwd);
+      return cwd ? { name: name, path: cwd } : null;
+    }
+    case 'git': {
+      var branch = cachedGit('branch', GIT_BRANCH_TTL, function () {
+        try {
+          return require('child_process').execFileSync(
+            'git', ['rev-parse', '--abbrev-ref', 'HEAD'],
+            { cwd: cwd, stdio: ['ignore', 'pipe', 'ignore'], timeout: 3000, windowsHide: true }
+          ).toString().trim() || null;
+        } catch (e) { return null; }
+      });
+      if (!branch) return null;
+      // workspace.repo is optional (parsed from the git remote) \u2014 the token
+      // stays empty when absent so the default {branch} format is unaffected.
+      var repoInfo = input.workspace && input.workspace.repo;
+      var sync = cachedGit('sync', GIT_SYNC_TTL, function () { return gitAheadBehind(cwd); });
+      return {
+        branch: branch,
+        repo: repoInfo && repoInfo.owner ? repoInfo.owner + '/' + repoInfo.name : '',
+        ahead: sync ? sync.ahead : '',
+        behind: sync ? sync.behind : '',
+        sync: sync ? sync.sync : ''
+      };
+    }
+    case 'git_user':
+      return cachedGit('git_user', GIT_IDENTITY_TTL, function () {
+        // Both fields must be set \u2014 a partial identity would render 'name <>'
+        var gitUser = gitConfigValue(cwd, 'user.name');
+        var gitEmail = gitConfigValue(cwd, 'user.email');
+        return gitUser && gitEmail ? { user: gitUser, email: gitEmail } : null;
+      });
+    case 'changes':
+      return cachedGit('changes', GIT_CHANGES_TTL, function () {
+        var diff = gitNumstat(cwd);
+        return diff ? { added: diff.added, deleted: diff.deleted, files: diff.files } : null;
+      });
+    case 'model': {
+      var model = (input.model && input.model.display_name) || '';
+      return model ? { model: model } : null;
+    }
+    case 'thinking': {
+      var level = (input.effort && input.effort.level)
+        || (input.thinking && input.thinking.enabled && 'thinking');
+      return level ? { level: level } : null;
+    }
+    case 'context': {
+      var cw = input.context_window || {};
+      var pct = pctOf(cw.used_percentage);
+      if (pct == null) return null;
+      var size = cw.context_window_size || 0;
+      var remaining = pctOf(cw.remaining_percentage);
+      return {
+        bar: barFor(pct, CONFIG.bar),
+        percent: pct,
+        used: humanize(contextUsed(cw, size, pct)),
+        total: humanize(size),
+        remaining: remaining == null ? '' : remaining,
+      };
+    }
+    case 'tokens': {
+      var cw2 = input.context_window || {};
+      if (seg && seg.metric === 'context') {
+        var used = cw2.total_input_tokens != null
+          ? cw2.total_input_tokens + (cw2.total_output_tokens || 0)
+          : (input.usage && input.usage.input_tokens != null ? input.usage.input_tokens : null);
+        if (used == null) return null;
+        var p = pctOf(cw2.used_percentage);
+        return { total: humanize(used), percent: p == null ? '' : p };
+      }
+      var session = sessionTokens(input.transcript_path);
+      return session == null ? null : { total: humanize(session), percent: '' };
+    }
+    case 'cost': {
+      var cost =
+        (input.cost && input.cost.total_cost_usd) ||
+        (input.session && input.session.cost_usd) ||
+        input.total_cost_usd;
+      if (cost == null) return null;
+      var costObj = input.cost || {};
+      return {
+        cost: '$' + Number(cost).toFixed(2),
+        duration: humanizeMs(costObj.total_duration_ms),
+        api_duration: humanizeMs(costObj.total_api_duration_ms),
+        lines_added: costObj.total_lines_added != null ? String(costObj.total_lines_added) : '',
+        lines_removed: costObj.total_lines_removed != null ? String(costObj.total_lines_removed) : ''
+      };
+    }
+    case 'rate': {
+      // Which window to report: five_hour (default), seven_day or spend.
+      var win = (seg && seg.window) || 'five_hour';
+      // the payload spells the third window 'spend_limit', not 'spend'
+      var rlKey = win === 'spend' ? 'spend_limit' : win;
+      var rl = input.rate_limits && input.rate_limits[rlKey];
+      var rp = rl && pctOf(rl.used_percentage);
+      if (rp == null) return null;
+      var limitLabel = win === 'seven_day' ? '7d' : win === 'spend' ? 'spend' : '5h';
+      return { percent: rp, limit: limitLabel, resets: rl.resets_at || '' };
+    }
+    case 'version':
+      return input.version ? { version: input.version } : null;
+    case 'output_style':
+      return input.output_style && input.output_style.name
+        ? { style: input.output_style.name }
+        : null;
+    case 'session': {
+      // Named sessions show their name; anonymous ones fall back to the id
+      // prefix so the block always has something to render.
+      if (input.session_name) return { name: String(input.session_name).slice(0, 40) };
+      return input.session_id ? { name: String(input.session_id).slice(0, 8) } : null;
+    }
+    case 'exceeds200k':
+      return input.exceeds_200k_tokens ? { over: '200k' } : null;
+    case 'fast_mode':
+      return input.fast_mode ? { mode: 'fast' } : null;
+    case 'vim':
+      return input.vim && input.vim.mode ? { mode: input.vim.mode } : null;
+    case 'pr': {
+      var prInfo = input.pr;
+      return prInfo && prInfo.number != null
+        ? {
+            number: prInfo.number,
+            state: prInfo.review_state || prInfo.kind || '',
+            url: prInfo.url || ''
+          }
+        : null;
+    }
+    case 'worktree': {
+      var wtInfo = input.worktree;
+      return wtInfo && (wtInfo.name || wtInfo.branch)
+        ? { name: wtInfo.name || '', branch: wtInfo.branch || '' }
+        : null;
+    }
+    case 'agent':
+      return input.agent && input.agent.name ? { name: input.agent.name } : null;
+    case 'time':
+      return { time: new Date().toLocaleTimeString() };
+    default:
+      return null;
+  }
+}
+
+// A segment's value template: an explicit format wins, then the legacy
+// context.style field, then the built-in default that predates templates.
+function formatFor(key, seg) {
+  if (seg.format) return seg.format;
+  if (key === 'context' && seg.style && CONTEXT_FORMAT[seg.style]) return CONTEXT_FORMAT[seg.style];
+  return SEGMENT_FORMAT[key] || '{value}';
+}
+
+// Collect the enabled, non-empty segments in the row's order as render items.
+// An item with merge:true joins the next non-merge block (shares its
+// background) \u2014 the same convention ccstatusline uses for icon-then-label pairs.
+function renderParts(keys) {
+  var out = [];
+  for (var i = 0; i < keys.length; i++) {
+    var seg = CONFIG.segments[keys[i]];
+    if (!seg || !seg.enabled) continue;
+    var tokens = segmentTokens(keys[i], seg);
+    if (!tokens) continue;
+    // trim: an optional token left empty ('{branch} {sync}' with nothing to
+    // sync) must not leave a dangling separator around an otherwise good block
+    var value = applyFormat(tokens, formatFor(keys[i], seg)).trim();
+    if (value === '') continue;
+    var label = seg.label
+      ? seg.label + (CONFIG.labelSeparator == null ? ': ' : CONFIG.labelSeparator)
+      : '';
+    out.push({
+      text: (seg.icon ? seg.icon + ' ' : '') + label + value,
+      fg: seg.color,
+      bold: seg.bold,
+      bg: seg.backgroundColor,
+      merge: !!seg.merge
+    });
+  }
+  return out;
+}
+
+function renderLine(items) {
+  var pending = [];
+  var ordered = [];
+  for (var i = 0; i < items.length; i++) {
+    if (items[i].merge) { pending.push(items[i]); continue; }
+    // the merge segments before this item join this block, sharing its bg \u2014
+    // they render flush against it (no separator of any kind)
+    for (var m = 0; m < pending.length; m++) {
+      pending[m].bg = items[i].bg;
+      pending[m].joinsNext = true;
+    }
+    ordered = ordered.concat(pending);
+    pending = [];
+    ordered.push(items[i]);
+  }
+  // trailing merge segments have no following block; drop their background
+  for (var j = 0; j < pending.length; j++) pending[j].bg = null;
+  ordered = ordered.concat(pending);
+
+  var isPower = !!(CONFIG.powerline && CONFIG.powerline.enabled);
+
+  // Caps frame the run of backgrounded blocks. An item without a background
+  // (the logo, or a segment whose bg was dropped) sits outside that run, so the
+  // caps attach to the first/last block rather than to the row's extremes.
+  var firstBg = -1;
+  var lastBg = -1;
+  for (var b = 0; b < ordered.length; b++) {
+    if (ordered[b].bg) {
+      if (firstBg < 0) firstBg = b;
+      lastBg = b;
+    }
+  }
+
+  var parts = [];
+  var plainParts = [];
+  for (var k = 0; k < ordered.length; k++) {
+    var it = ordered[k];
+    // a merge segment joins the item after it, so no separator goes between
+    if (k > 0 && !ordered[k - 1].joinsNext) {
+      var prev = ordered[k - 1];
+      if (isPower && prev.bg && it.bg) {
+        // powerline bridge (ccstatusline): the join glyph's fg is the previous
+        // block's bg and its bg is the next block's, so the two blocks melt
+        // into one chevron; when both blocks share a bg the glyph keeps the
+        // previous block's fg so they read as a single block
+        var bridgeFg = prev.bg === it.bg ? prev.fg : prev.bg;
+        parts.push(paint(GLYPH_JOIN, bridgeFg, false, it.bg));
+        plainParts.push(GLYPH_JOIN);
+      } else if (isPower) {
+        parts.push(' '); // a block without bg gets a plain gap, never a '\u2502'
+        plainParts.push(' ');
+      } else {
+        parts.push(CONFIG.separator);
+        plainParts.push(CONFIG.separator);
+      }
+    }
+    // an empty cap config ("" / disabled) skips that cap entirely
+    if (isPower && k === firstBg && GLYPH_START) {
+      parts.push(paint(GLYPH_START, it.bg, false, null));
+      plainParts.push(GLYPH_START);
+    }
+    if (isPower) {
+      parts.push(paint(' ' + it.text + ' ', it.fg, it.bold, it.bg));
+      plainParts.push(' ' + it.text + ' ');
+    } else {
+      parts.push(paint(it.text, it.fg, it.bold, null));
+      plainParts.push(it.text);
+    }
+    if (isPower && k === lastBg && GLYPH_END) {
+      parts.push(paint(GLYPH_END, it.bg, false, null));
+      plainParts.push(GLYPH_END);
+    }
+  }
+  return { line: parts.join(''), plain: plainParts.join('') };
+}
+
+// Pad the line so it sits left / centre / right of the terminal width. The
+// script runs as a subprocess, so it falls back to a sane default width. A
+// small safety margin keeps the statusline clear of the terminal's right
+// edge (ccstatusline reserves 6 columns for the same reason).
+function alignLine(rendered) {
+  if (CONFIG.align === 'left') return rendered.line;
+  var cols =
+    (input.terminal && (input.terminal.columns || input.terminal.width)) ||
+    (process.stdout && process.stdout.columns) ||
+    80;
+  var usable = Math.max(20, cols - 6);
+  var pad = 0;
+  if (CONFIG.align === 'right') pad = Math.max(0, usable - rendered.plain.length - 2);
+  else pad = Math.max(0, Math.floor((usable - rendered.plain.length) / 2));
+  if (pad <= 0) return rendered.line;
+  return new Array(pad + 1).join(' ') + rendered.line;
+}
+
+// The logo is always rendered \u2014 it identifies the statusline as weave's and
+// carries the version that generated this script. Only its text/colour vary.
+function logoItem() {
+  return {
+    text: CONFIG.logoText + ' v' + WEAVE_VERSION,
+    fg: CONFIG.logoColor,
+    bold: true,
+    bg: null,
+    merge: false
+  };
+}
+
+// Ordered rows; each row is the left-to-right segment order. The logo prefixes
+// row 0 only; rows are joined with a dim divider.
+var rows = CONFIG.lines && CONFIG.lines.length ? CONFIG.lines : [${JSON.stringify(p)}];
+var renderedLines = [];
+for (var li = 0; li < rows.length; li++) {
+  var items = renderParts(rows[li]);
+  if (li === 0) items.unshift(logoItem());
+  // lead each content line with a reset so Claude Code's dim setting for the
+  // statusline area does not wash out our colours (ccstatusline does the same)
+  renderedLines.push('\\x1b[0m' + alignLine(renderLine(items)));
+  // the row divider is configurable and empty by default (the reference
+  // layout stacks its rows with no rule between them)
+  if (li < rows.length - 1 && CONFIG.divider) renderedLines.push(dim(CONFIG.divider));
+}
+process.stdout.write(renderedLines.join('\\n'));
+}
+
+// stdin: \u5BBF\u4E3B\u5199\u5B8C\u5373\u5173\u95ED\u3002\u539F\u5148\u7528\u540C\u6B65 readFileSync(0) \u2014\u2014 \u5BBF\u4E3B\u4E0D\u5173\u95ED stdin \u65F6\u5B83\u4F1A\u628A
+// \u4E8B\u4EF6\u5FAA\u73AF\u5835\u6B7B\uFF08\u8FDE\u5B88\u536B timer \u90FD\u6551\u4E0D\u4E86\uFF09\uFF0C\u8FDB\u7A0B\u6C38\u4E45\u6EDE\u7559\uFF08\u5B9E\u6D4B 3 \u5C0F\u65F6\u6512\u4E86 77 \u4E2A\u5B64\u513F\uFF09\u3002
+// \u6539\u5F02\u6B65\u8BFB + \u515C\u5E95 timer\uFF0C\u4F7F\u4E0B\u9762\u7684\u5B88\u536B\u771F\u6B63\u751F\u6548\u3002
+var raw = '';
+var flushed = false;
+function flush() {
+  if (flushed) return;
+  flushed = true;
+  try { main(raw); } catch (e) {}
+  // \u7F13\u5B58\u56DE\u5199\u5728\u6E32\u67D3\u4E4B\u540E\uFF1A\u4E3B\u6D41\u7A0B\u4E2D\u9014\u629B\u9519\u4E5F\u4FDD\u4F4F\u8FD9\u4E00\u8F6E\u626B\u5230\u7684\u589E\u91CF
+  try { flushCache(); } catch (e) {}
+  try { flushGitCache(); } catch (e) {}
+  process.exit(0);
+}
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', function (c) { raw += c; });
+process.stdin.on('end', flush);
+setTimeout(flush, 700).unref();
+// \u786C\u5B88\u536B\uFF1A\u4EFB\u4F55\u8DEF\u5F84\u90FD\u4E0D\u8BB8\u8D56\u7740\u4E0D\u8D70\uFF08\u6B63\u5E38\u4E00\u6B21\u6E32\u67D3\u662F\u6BEB\u79D2\u7EA7\uFF09\u3002
+setTimeout(function () { process.exit(0); }, 5000).unref();
+`}