agy-powerline 1.2.0 → 1.3.0

package/src/lib/catalog.js

@@ -126,8 +126,45 @@ const WIDGET_CATALOG = [
     id: "git",
     label: "VCS Branch",
     unique: true,
-    description: "current branch, marked when there are uncommitted changes",
-    summary: "branch and uncommitted changes",
+    description:
+      "current branch, marked when there are uncommitted changes, with how many commits it is ahead of or behind its upstream",
+    summary: "branch, changes and ahead/behind",
+  },
+  {
+    id: "gitChanges",
+    label: "Git Line Changes",
+    unique: true,
+    description:
+      "lines added and removed since the last commit, staged or not (new files that aren't staged don't count)",
+    summary: "lines added and removed",
+  },
+  {
+    id: "gitFiles",
+    label: "Git File Counts",
+    unique: true,
+    description: "how many files are staged, modified, untracked and in conflict",
+    summary: "staged, modified, untracked file counts",
+  },
+  {
+    id: "gitSha",
+    label: "Git Commit",
+    unique: true,
+    description: "short ID of the commit checked out",
+    summary: "short commit ID",
+  },
+  {
+    id: "gitStash",
+    label: "Git Stash Count",
+    unique: true,
+    description: "how many stashes the repository holds; hidden when there are none",
+    summary: "number of stashes",
+  },
+  {
+    id: "gitWorktree",
+    label: "Git Worktree",
+    unique: true,
+    description: "name of the linked worktree you're in; hidden in the main one",
+    summary: "linked worktree name",
   },
   {
     id: "plan",
@@ -220,6 +257,21 @@ const WIDGET_CATALOG = [
     description: "session tokens, as a total or split into input and output",
     summary: "session tokens, total or split",
   },
+  {
+    id: "tokensToday",
+    label: "Tokens Today",
+    unique: true,
+    description: "tokens used today in all agy conversations, from agy's local data (Node 22.13+)",
+    summary: "tokens used today, all conversations",
+  },
+  {
+    id: "tokensWeek",
+    label: "Tokens 7 Days",
+    unique: true,
+    description:
+      "tokens used in the last 7 days in all agy conversations, from agy's local data (Node 22.13+)",
+    summary: "tokens used over 7 days",
+  },
   {
     id: "exec",
     label: "Shell Command",

package/src/lib/colors.js

@@ -196,6 +196,122 @@ function parseColor(value, fallback = [200, 200, 200]) {
   return fallback;
 }
 
+function linear(c) {
+  const v = c / 255;
+  return v <= 0.04045 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4;
+}
+
+function gamma(v) {
+  const c = v <= 0.0031308 ? 12.92 * v : 1.055 * v ** (1 / 2.4) - 0.055;
+  return Math.max(0, Math.min(255, Math.round(c * 255)));
+}
+
+// WCAG relative luminance and contrast ratio.
+function luminance([r, g, b]) {
+  return 0.2126 * linear(r) + 0.7152 * linear(g) + 0.0722 * linear(b);
+}
+
+function contrastRatio(a, b) {
+  const [hi, lo] = [luminance(a), luminance(b)].sort((x, y) => y - x);
+  return (hi + 0.05) / (lo + 0.05);
+}
+
+// OKLab (Björn Ottosson): mixing there keeps the middle of a gradient as
+// bright and saturated as its ends, where sRGB mixing turns it muddy.
+function toOklab([r, g, b]) {
+  const [lr, lg, lb] = [linear(r), linear(g), linear(b)];
+  const l = Math.cbrt(0.4122214708 * lr + 0.5363325363 * lg + 0.0514459929 * lb);
+  const m = Math.cbrt(0.2119034982 * lr + 0.6806995451 * lg + 0.1073969566 * lb);
+  const s = Math.cbrt(0.0883024619 * lr + 0.2817188376 * lg + 0.6299787005 * lb);
+  return [
+    0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
+    1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
+    0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s,
+  ];
+}
+
+function fromOklab([L, a, b]) {
+  const l = (L + 0.3963377774 * a + 0.2158037573 * b) ** 3;
+  const m = (L - 0.1055613458 * a - 0.0638541728 * b) ** 3;
+  const s = (L - 0.0894841775 * a - 1.291485548 * b) ** 3;
+  return [
+    gamma(4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s),
+    gamma(-1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s),
+    gamma(-0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s),
+  ];
+}
+
+const MAX_GRADIENT_STOPS = 6;
+const HEX_STOP = /^#?([0-9a-f]{3}|[0-9a-f]{6})$/i;
+
+// "#ff5f6d-#ffc371" (2 to 6 hex stops, "#" optional) to RGB stops, or null.
+function parseGradientStops(spec) {
+  if (typeof spec !== "string") {
+    return null;
+  }
+  const parts = spec.trim().split("-");
+  if (parts.length < 2 || parts.length > MAX_GRADIENT_STOPS) {
+    return null;
+  }
+  if (!parts.every((part) => HEX_STOP.test(part))) {
+    return null;
+  }
+  return parts.map((part) => parseColor(part));
+}
+
+// The color t (0 to 1) of the way along the stops; the ends are exact.
+function gradientAt(stops, t) {
+  const clamped = Math.max(0, Math.min(1, Number(t) || 0));
+  const span = clamped * (stops.length - 1);
+  const i = Math.min(stops.length - 2, Math.floor(span));
+  const local = span - i;
+  if (local === 0) {
+    return [...stops[i]];
+  }
+  if (local === 1) {
+    return [...stops[i + 1]];
+  }
+  const [a, b] = [toOklab(stops[i]), toOklab(stops[i + 1])];
+  return fromOklab(a.map((value, k) => value + (b[k] - value) * local));
+}
+
+// count evenly spaced colors from the first stop to the last.
+function gradientColors(stops, count) {
+  if (count <= 1) {
+    return count === 1 ? [[...stops[0]]] : [];
+  }
+  return Array.from({ length: count }, (_, i) => gradientAt(stops, i / (count - 1)));
+}
+
+const MIN_CONTRAST = 4.5;
+
+// The preferred text color if it reads on the background, else whichever of
+// the fallbacks contrasts most.
+function readableText(background, preferred, fallbacks) {
+  if (contrastRatio(preferred, background) >= MIN_CONTRAST) {
+    return preferred;
+  }
+  return fallbacks.reduce((best, color) =>
+    contrastRatio(color, background) > contrastRatio(best, background) ? color : best
+  );
+}
+
+// The color moved toward white (on a dark background) or black (on a light
+// one) just far enough to reach the minimum contrast.
+function withContrast(color, background, min = MIN_CONTRAST) {
+  if (contrastRatio(color, background) >= min) {
+    return color;
+  }
+  const target = luminance(background) < 0.5 ? [255, 255, 255] : [0, 0, 0];
+  for (let step = 1; step <= 20; step++) {
+    const moved = mix(color, target, step / 20);
+    if (contrastRatio(moved, background) >= min) {
+      return moved;
+    }
+  }
+  return target;
+}
+
 module.exports = {
   CSI,
   RESET,
@@ -221,4 +337,15 @@ module.exports = {
   shade,
   mix,
   parseColor,
+  luminance,
+  contrastRatio,
+  toOklab,
+  fromOklab,
+  MAX_GRADIENT_STOPS,
+  parseGradientStops,
+  gradientAt,
+  gradientColors,
+  MIN_CONTRAST,
+  readableText,
+  withContrast,
 };

package/src/lib/config-check.js

@@ -0,0 +1,74 @@
+"use strict";
+
+const { defaultConfig, canonicalThemeId, LAYOUTS } = require("./shared");
+const { THEMES, normalizeGradient } = require("./themes");
+const { VALID_WIDGET_IDS } = require("./config");
+const { COLOR_MODES } = require("./colors");
+const { isMeterStyle } = require("./widget-style");
+
+const KNOWN_KEYS = new Set([
+  ...Object.keys(defaultConfig()),
+  "customTheme",
+  "gradient",
+  "meterStyle",
+]);
+
+// Control characters shown as \uXXXX: the text is printed, never interpreted
+// by the terminal or the browser.
+function visible(text) {
+  return String(text).replace(
+    /[\x00-\x1f\x7f-\x9f\u2028\u2029\u202A-\u202E\u2066-\u2069]/g,
+    (char) => `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}`
+  );
+}
+
+// Settings the raw config has that the bar can't use, so they don't come over
+// on import or in the web configurator.
+function droppedSettings(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return ["config is not an object"];
+  }
+
+  const dropped = [];
+  for (const key of Object.keys(raw)) {
+    if (!KNOWN_KEYS.has(key)) {
+      dropped.push(`unknown setting "${visible(key)}"`);
+    }
+  }
+  if (Array.isArray(raw.widgets)) {
+    for (const widget of raw.widgets) {
+      if (!widget || typeof widget !== "object" || !VALID_WIDGET_IDS.has(widget.id)) {
+        dropped.push(`unknown widget ${visible(JSON.stringify(widget?.id ?? widget) ?? "")}`);
+      }
+    }
+  } else if (raw.widgets !== undefined) {
+    dropped.push("widgets (not a list)");
+  }
+  if (raw.theme !== undefined && !THEMES[canonicalThemeId(raw.theme)]) {
+    dropped.push(`unknown theme ${visible(JSON.stringify(raw.theme))}`);
+  }
+  if (raw.layout !== undefined && !LAYOUTS[raw.layout]) {
+    dropped.push(`unknown layout ${visible(JSON.stringify(raw.layout))}`);
+  }
+  if (raw.color !== undefined && !COLOR_MODES.includes(raw.color)) {
+    dropped.push(`unknown color mode ${visible(JSON.stringify(raw.color))}`);
+  }
+  if (
+    raw.gradient !== undefined &&
+    raw.gradient !== null &&
+    raw.gradient !== "off" &&
+    !normalizeGradient(raw.gradient)
+  ) {
+    dropped.push(`invalid gradient ${visible(JSON.stringify(raw.gradient))}`);
+  }
+  if (raw.meterStyle !== undefined && !isMeterStyle(raw.meterStyle)) {
+    dropped.push(`unknown meter style ${visible(JSON.stringify(raw.meterStyle))}`);
+  }
+  return dropped;
+}
+
+module.exports = {
+  KNOWN_KEYS,
+  visible,
+  droppedSettings,
+};

package/src/lib/config.js

@@ -3,10 +3,11 @@
 const fs = require("fs");
 const path = require("path");
 const { resolveColorModeId } = require("./colors");
-const { resolveThemeId } = require("./themes");
+const { resolveThemeId, normalizeGradient } = require("./themes");
 const { stripControl, normalizeClock } = require("./formatters");
 const { normalizePowerline } = require("./powerline");
 const { writeFileAtomic, PRIVATE_FILE_MODE } = require("./paths");
+const { isMeterStyle } = require("./widget-style");
 
 // Display text in widget configs is printed as-is, so strip terminal control
 // from it. cmd/command are left alone: they are executed, not printed.
@@ -39,6 +40,11 @@ const VALID_WIDGET_IDS = new Set([
   "cwd",
   "project",
   "git",
+  "gitChanges",
+  "gitFiles",
+  "gitSha",
+  "gitStash",
+  "gitWorktree",
   "plan",
   "agentState",
   "artifacts",
@@ -52,6 +58,8 @@ const VALID_WIDGET_IDS = new Set([
   "cacheCreate",
   "cacheHit",
   "totalTokens",
+  "tokensToday",
+  "tokensWeek",
   "exec",
   "customText",
   "separator",
@@ -175,6 +183,17 @@ function mergeConfig(raw) {
     result.customTheme = raw.customTheme;
   }
 
+  // An unknown meter style is left out: each layout then draws its own.
+  if (isMeterStyle(raw?.meterStyle)) {
+    result.meterStyle = raw.meterStyle;
+  }
+
+  // Only a valid gradient is kept; anything else renders the plain theme.
+  const gradient = normalizeGradient(raw?.gradient);
+  if (gradient) {
+    result.gradient = gradient;
+  }
+
   return result;
 }
 

package/src/lib/exec.js

@@ -5,7 +5,8 @@ const path = require("path");
 const os = require("os");
 const crypto = require("crypto");
 const { execSync } = require("child_process");
-const { stripControl } = require("./formatters");
+const { stripControl, sanitizeDeep } = require("./formatters");
+const { RESET, getActiveDepth } = require("./colors");
 const { logWarning } = require("./log");
 const { PRIVATE_FILE_MODE } = require("./paths");
 
@@ -92,16 +93,123 @@ function cacheKey(cmd, cwd = "") {
     .slice(0, 16);
 }
 
+// The only escape sequence "colors": true keeps: SGR color and style. Colon
+// forms (38:2::r:g:b) are dropped with the rest, since not every terminal reads them.
+const SGR_SPLIT = /(\x1b\[[0-9;]*m)/;
+const SGR_ALL = /\x1b\[([0-9;]*)m/g;
+
 // Command output is untrusted text: strip terminal control and cap length.
-function sanitizeExecOutput(text) {
-  const clean = stripControl(text).trim();
-  const chars = Array.from(clean);
+// With colors, SGR sequences survive and the visible text alone is capped;
+// the output then ends with a reset so its colors can't leak past it.
+function sanitizeExecOutput(text, { colors = false } = {}) {
+  if (!colors) {
+    const clean = stripControl(text).trim();
+    const chars = Array.from(clean);
+
+    if (chars.length <= MAX_OUTPUT_CHARS) {
+      return clean;
+    }
+
+    return chars.slice(0, MAX_OUTPUT_CHARS - 1).join("") + "…";
+  }
+
+  const parts = String(text ?? "")
+    .split(SGR_SPLIT)
+    .map((part, i) => (i % 2 ? part : stripControl(part)));
+  const visible = parts.filter((_, i) => i % 2 === 0).join("");
+  const lead = visible.length - visible.trimStart().length;
+  const chars = Array.from(visible.trim());
+  const cut = chars.length > MAX_OUTPUT_CHARS;
+  const budget = cut ? MAX_OUTPUT_CHARS - 1 : chars.length;
+  let skip = lead;
+  let used = 0;
+  let out = "";
+  let styled = false;
+
+  for (let i = 0; i < parts.length && used < budget; i++) {
+    if (i % 2) {
+      out += parts[i];
+      styled = true;
+      continue;
+    }
+    for (const char of Array.from(parts[i])) {
+      if (skip > 0) {
+        skip -= char.length;
+        continue;
+      }
+      if (used === budget) {
+        break;
+      }
+      out += char;
+      used++;
+    }
+  }
 
-  if (chars.length <= MAX_OUTPUT_CHARS) {
-    return clean;
+  return out + (cut ? "…" : "") + (styled ? RESET : "");
+}
+
+// After a reset in colored output, the widget's own colors come back (the
+// pill's background and text in Pills), so the rest of the widget isn't left
+// in the terminal's default colors.
+function restoreAfterReset(text, restore) {
+  if (!restore) {
+    return text;
   }
+  return String(text).replace(SGR_ALL, (seq, body) => {
+    const params = body === "" ? [0] : body.split(";").map((p) => (p === "" ? 0 : Number(p)));
+    let lastReset = -1;
+    for (let i = 0; i < params.length; i++) {
+      // 38/48/58 take a color as their next parameters; a 0 there isn't a reset.
+      if (params[i] === 38 || params[i] === 48 || params[i] === 58) {
+        i += params[i + 1] === 5 ? 2 : params[i + 1] === 2 ? 4 : 0;
+      } else if (params[i] === 0) {
+        lastReset = i;
+      }
+    }
+    if (lastReset < 0) {
+      return seq;
+    }
+    const rest = params.slice(lastReset + 1);
+    return `${RESET}${restore}${rest.length ? `\x1b[${rest.join(";")}m` : ""}`;
+  });
+}
+
+// Never handed to a command: agy-powerline doesn't read the account email or
+// the session and conversation IDs, so it doesn't pass them on either.
+const PRIVATE_KEYS = new Set(["email", "session_id", "conversation_id"]);
+
+function withoutPrivateKeys(value, depth = 0) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (depth > 8) {
+    return undefined;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => withoutPrivateKeys(item, depth + 1));
+  }
+  const out = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (!PRIVATE_KEYS.has(key)) {
+      out[key] = withoutPrivateKeys(item, depth + 1);
+    }
+  }
+  return out;
+}
+
+// The session JSON an exec widget with "payload": true reads on stdin.
+function execPayloadJson(payload) {
+  try {
+    return JSON.stringify(sanitizeDeep(withoutPrivateKeys(payload ?? {}))) ?? "{}";
+  } catch {
+    return "{}";
+  }
+}
 
-  return chars.slice(0, MAX_OUTPUT_CHARS - 1).join("") + "…";
+// Widgets that share a command but not its options must not share its output.
+function widgetCacheKey(widget, cwd) {
+  const variant = `${widget.payload === true ? "\0payload" : ""}${widget.colors === true ? "\0colors" : ""}`;
+  return cacheKey(`${String(widget.cmd).trim()}${variant}`, cwd);
 }
 
 // session.execMode: "run" executes the command, "blocked" marks a config the
@@ -115,11 +223,12 @@ function execWidgetOutput(widget, session = {}) {
     // Fitting the bar to the terminal can draw a row several times; a command
     // still runs at most once per refresh, even with "interval": 0.
     const memo = session.execMemo;
-    const key = cacheKey(widget.cmd, session.cwd || process.cwd());
+    const key = widgetCacheKey(widget, session.cwd || process.cwd());
     if (memo?.has(key)) {
       return memo.get(key);
     }
-    const output = sanitizeExecOutput(runExecWidget(widget, session));
+    const colors = widget.colors === true && getActiveDepth() !== "none";
+    const output = sanitizeExecOutput(runExecWidget(widget, session), { colors });
     memo?.set(key, output);
     return output;
   }
@@ -134,14 +243,15 @@ function runExecWidget(widget, session = {}) {
   }
 
   const cwd = session.cwd || process.cwd();
-  const key = cacheKey(cmd, cwd);
+  const key = widgetCacheKey(widget, cwd);
   const now = Date.now();
+  const input = widget.payload === true ? `${session.execPayload || "{}"}\n` : undefined;
 
   let intervalMs = DEFAULT_INTERVAL_SEC * 1000;
   if (widget.interval != null) {
     const parsed = Number(widget.interval);
     if (Number.isFinite(parsed) && parsed >= 0) {
-      intervalMs = parsed >= 1000 ? parsed : parsed * 1000;
+      intervalMs = parsed * 1000;
     }
   }
 
@@ -169,24 +279,30 @@ function runExecWidget(widget, session = {}) {
 
   // 3. Cache expired or missing: execute command with timeout
   let output = diskHit?.output || memHit?.output || "";
+  const firstLine = (stdout) =>
+    String(stdout || "")
+      .trim()
+      .split(/\r?\n/)[0]
+      ?.trim() || "";
   try {
     const stdout = execSync(cmd, {
       cwd,
       timeout: timeoutMs,
       encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
+      input,
+      stdio: [input === undefined ? "ignore" : "pipe", "pipe", "ignore"],
       windowsHide: true,
     });
-    output =
-      String(stdout || "")
-        .trim()
-        .split(/\r?\n/)[0]
-        ?.trim() || "";
+    output = firstLine(stdout);
   } catch (err) {
-    // Keep the previous output. A non-zero exit is normal for many commands
-    // (grep with no match), so only timeouts and missing commands are logged,
-    // and never the command itself.
-    if (err.code === "ETIMEDOUT" || err.signal === "SIGTERM") {
+    // A command that exits without reading the whole payload closes the pipe
+    // under the write; it still succeeded, so its output counts. Otherwise the
+    // previous output stays. A non-zero exit is normal for many commands (grep
+    // with no match), so only timeouts and missing commands are logged, and
+    // never the command itself.
+    if (input !== undefined && err.status === 0 && !err.signal) {
+      output = firstLine(err.stdout);
+    } else if (err.code === "ETIMEDOUT" || err.signal === "SIGTERM") {
       logWarning("EXEC_TIMEOUT", { timeoutMs });
     } else if (err.status === 127 || err.code === "ENOENT") {
       logWarning("EXEC_COMMAND_NOT_FOUND");
@@ -223,6 +339,9 @@ module.exports = {
   runExecWidget,
   execWidgetOutput,
   sanitizeExecOutput,
+  restoreAfterReset,
+  execPayloadJson,
+  widgetCacheKey,
   cacheKey,
   clearExecCache,
   getCacheFilePath,

package/src/lib/fit.js

@@ -6,12 +6,16 @@ const { charWidth, visibleWidth } = require("./formatters");
 // first entry first. Ids not listed (custom ones) go before all of them.
 const DROP_ORDER = [
   "customText",
+  "gitStash",
+  "gitWorktree",
   "title",
   "version",
   "cacheCreate",
   "cacheRead",
   "totalTokens",
   "cacheHit",
+  "tokensToday",
+  "tokensWeek",
   "artifacts",
   "tasks",
   "plan",
@@ -28,6 +32,9 @@ const DROP_ORDER = [
   "weeklyReset",
   "fiveHourReset",
   "contextTokens",
+  "gitSha",
+  "gitFiles",
+  "gitChanges",
   "git",
   "sandbox",
   "weeklyPct",

package/src/lib/formatters.js

@@ -271,6 +271,24 @@ function formatTokenSplit(input, output, ascii = false) {
     : `${formatTokens(input)}↑ ${formatTokens(output)}↓`;
 }
 
+// The usage widgets' text: "1.2M", or "1.0M↑ 245.3K↓" with "split", plus the
+// share of a "budget" when one is set ("1.2M (60%)"). null with no tokens.
+function formatUsage(tokens, widget = {}, ascii = false) {
+  const input = Number(tokens?.input) || 0;
+  const output = Number(tokens?.output) || 0;
+  const total = input + output;
+  if (!(total > 0)) {
+    return null;
+  }
+  const value = widget?.split ? formatTokenSplit(input, output, ascii) : formatTokens(total);
+  const budget = widget?.budget;
+  const pct =
+    typeof budget === "number" && Number.isFinite(budget) && budget > 0
+      ? (total * 100) / budget
+      : null;
+  return { text: pct === null ? value : `${value} (${Math.round(pct)}%)`, pct };
+}
+
 // "used/window", or just the used tokens while the window size is unknown.
 function formatContextTokens(used, size) {
   return size > 0 ? `${formatTokens(used)}/${formatTokens(size)}` : formatTokens(used);
@@ -460,6 +478,31 @@ function visibleWidth(text) {
   return width;
 }
 
+// "+128 −34" as parts, so Lines can color each; zero counts are left out.
+function gitChangeParts(changes, ascii = false) {
+  const parts = [];
+  if (changes?.added > 0) {
+    parts.push({ kind: "added", text: `+${changes.added}` });
+  }
+  if (changes?.removed > 0) {
+    parts.push({ kind: "removed", text: `${ascii ? "-" : "−"}${changes.removed}` });
+  }
+  return parts;
+}
+
+const GIT_FILE_MARKS = {
+  unicode: { staged: "+", modified: "●", untracked: "?", conflicts: "≠" },
+  ascii: { staged: "S", modified: "M", untracked: "?", conflicts: "!" },
+};
+
+// "+2 ●3 ?1 ≠1" as parts: staged, modified, untracked, in conflict.
+function gitFileParts(files, ascii = false) {
+  const marks = GIT_FILE_MARKS[ascii ? "ascii" : "unicode"];
+  return Object.keys(marks)
+    .filter((kind) => files?.[kind] > 0)
+    .map((kind) => ({ kind, text: `${marks[kind]}${files[kind]}` }));
+}
+
 function formatGitSync(ahead, behind, ascii = false) {
   const up = ascii ? "^" : "⇡";
   const down = ascii ? "v" : "⇣";
@@ -477,6 +520,26 @@ function formatGitSync(ahead, behind, ascii = false) {
   return "";
 }
 
+const GIT_OPERATION_LABELS = {
+  rebase: "REBASE",
+  am: "AM",
+  merge: "MERGING",
+  "cherry-pick": "CHERRY-PICKING",
+  revert: "REVERTING",
+  bisect: "BISECTING",
+};
+
+// "REBASE 2/5", "MERGING", or "" with no operation. Plain ASCII in both modes.
+function formatGitOperation(op) {
+  const name = GIT_OPERATION_LABELS[op?.name];
+  if (!name) {
+    return "";
+  }
+  return Number.isInteger(op.step) && Number.isInteger(op.total)
+    ? `${name} ${op.step}/${op.total}`
+    : name;
+}
+
 // "2 subagents, 1 task", or "" when nothing runs.
 function formatTasks(subagents, tasks) {
   const part = (n, word) => (n > 0 ? `${n} ${word}${n === 1 ? "" : "s"}` : "");
@@ -585,7 +648,11 @@ module.exports = {
   formatContextTokens,
   shortModelName,
   formatTokenSplit,
+  formatUsage,
   formatGitSync,
+  formatGitOperation,
+  gitChangeParts,
+  gitFileParts,
   formatTasks,
   formatMode,
   clipText,