agy-powerline 1.2.0 → 1.3.0

package/src/lib/layouts/lines.js

@@ -1,6 +1,17 @@
 "use strict";
 
-const { rgb, fg, RESET, DIM, BOLD, NORMAL, BLINK } = require("../colors");
+const {
+  rgb,
+  fg,
+  RESET,
+  DIM,
+  BOLD,
+  NORMAL,
+  BLINK,
+  gradientColors,
+  withContrast,
+} = require("../colors");
+const { gradientStops, terminalBackground } = require("../themes");
 const {
   basenameOf,
   homePath,
@@ -8,6 +19,9 @@ const {
   paceIndex,
   paceGlyph,
   formatGitSync,
+  formatGitOperation,
+  gitChangeParts,
+  gitFileParts,
   formatTasks,
   formatMode,
   clipText,
@@ -15,12 +29,13 @@ const {
   formatContextTokens,
   shortModelName,
   formatTokenSplit,
+  formatUsage,
   resolveQuotaThresholds,
   resolveContextThresholds,
   shouldBlink,
 } = require("../formatters");
 const { joinFlex } = require("./pills");
-const { execWidgetOutput } = require("../exec");
+const { execWidgetOutput, restoreAfterReset } = require("../exec");
 const {
   NAMED_COLORS,
   resolveColor,
@@ -28,6 +43,8 @@ const {
   widgetTag,
   isRaw,
   isPaced,
+  METER_STYLES,
+  meterStyle,
   hasNoData,
   RAM_CAUTION,
   RAM_DANGER,
@@ -126,13 +143,14 @@ function renderDotMeter(
       : colorForUsedPct(pct, palette, options));
 
   const marker = paceIndex(options.elapsedPct, width);
+  const [full, blank] = METER_STYLES[options.style] || METER_STYLES.dots;
 
   if (marker < 0) {
     if (ascii) {
       return fg(color) + "#".repeat(filled) + DIM + "-".repeat(empty) + RESET;
     }
     const trackColor = palette.track || rgb(60, 65, 75);
-    return fg(color) + "●".repeat(filled) + fg(trackColor) + "●".repeat(empty) + RESET;
+    return fg(color) + full.repeat(filled) + fg(trackColor) + blank.repeat(empty) + RESET;
   }
 
   // The marker replaces the dot where the quota window currently is.
@@ -145,9 +163,9 @@ function renderDotMeter(
     if (i === marker) {
       out += undim + fg(markerColor) + paceGlyph(ascii);
     } else if (i < filled) {
-      out += undim + fg(color) + (ascii ? "#" : "●");
+      out += undim + fg(color) + (ascii ? "#" : full);
     } else {
-      out += ascii ? DIM + "-" : fg(trackColor) + "●";
+      out += ascii ? DIM + "-" : fg(trackColor) + blank;
     }
   }
   return out + RESET;
@@ -159,8 +177,10 @@ function buildLinesSegment(id, session, palette, emojis, ascii = false, widget =
   const tag = (icon) => widgetTag(id, { emojis, raw, icon });
   // Meters: 25 dots, or 12 when the bar is fitted to a narrow terminal.
   const dots = widget?.compact ? 12 : 25;
+  const style = meterStyle(widget, config, "lines");
   const pace = (quota, thresh) => ({
     ...thresh,
+    style,
     elapsedPct: isPaced(widget, config) ? quota.elapsedPct : null,
   });
   const over200k = session.exceeds200k ? " >200k" : "";
@@ -304,7 +324,11 @@ function buildLinesSegment(id, session, palette, emojis, ascii = false, widget =
         blinkSeq +
         fg(palette.text) +
         tag() +
-        renderDotMeter(session.contextPct, dots, ascii, palette, false, { ...thresh, color }) +
+        renderDotMeter(session.contextPct, dots, ascii, palette, false, {
+          ...thresh,
+          color,
+          style,
+        }) +
         " " +
         fg(color) +
         `${formatContextTokens(session.usedTokens, session.contextSize)} ` +
@@ -357,6 +381,7 @@ function buildLinesSegment(id, session, palette, emojis, ascii = false, widget =
       if (!session.git || !session.git.branch) {
         return null;
       }
+      const opStr = widget.operation === false ? "" : formatGitOperation(session.git.operation);
       const syncStr = formatGitSync(session.git.ahead, session.git.behind, ascii);
       const syncPart = syncStr ? ` ${syncStr}` : "";
       return (
@@ -365,6 +390,7 @@ function buildLinesSegment(id, session, palette, emojis, ascii = false, widget =
         "(" +
         session.git.branch +
         (session.git.dirty ? `${fg(palette.gitDirty)}*` : "") +
+        (opStr ? `${fg(palette.gitDirty)} ${opStr}` : "") +
         (syncPart ? `${fg(palette.git)}${syncPart}` : "") +
         fg(palette.git) +
         ")" +
@@ -372,6 +398,52 @@ function buildLinesSegment(id, session, palette, emojis, ascii = false, widget =
       );
     }
 
+    case "gitChanges": {
+      const parts = gitChangeParts(session.gitDetails?.changes, ascii);
+      if (!parts.length) {
+        return null;
+      }
+      const shade = { added: palette.quotaLow, removed: palette.quotaCrit };
+      return (
+        fg(palette.git) +
+        tag() +
+        parts.map((part) => fg(shade[part.kind]) + part.text).join(" ") +
+        RESET
+      );
+    }
+
+    case "gitFiles": {
+      const parts = gitFileParts(session.gitDetails?.files, ascii);
+      if (!parts.length) {
+        return null;
+      }
+      const shade = (kind) => (kind === "conflicts" ? palette.quotaCrit : palette.git);
+      return (
+        fg(palette.git) +
+        tag() +
+        parts.map((part) => fg(shade(part.kind)) + part.text).join(" ") +
+        RESET
+      );
+    }
+
+    case "gitSha":
+      if (!session.gitDetails?.sha) {
+        return null;
+      }
+      return fg(palette.git) + tag() + session.gitDetails.sha + RESET;
+
+    case "gitStash":
+      if (!(session.gitDetails?.stash > 0)) {
+        return null;
+      }
+      return fg(palette.git) + tag() + session.gitDetails.stash + RESET;
+
+    case "gitWorktree":
+      if (!session.gitDetails?.worktree) {
+        return null;
+      }
+      return fg(palette.git) + tag() + session.gitDetails.worktree + RESET;
+
     case "plan":
       if (!session.plan) {
         return null;
@@ -474,6 +546,32 @@ function buildLinesSegment(id, session, palette, emojis, ascii = false, widget =
         RESET
       );
 
+    case "tokensToday":
+    case "tokensWeek": {
+      const usage = formatUsage(
+        session.usage?.[id === "tokensToday" ? "today" : "week"],
+        widget,
+        ascii
+      );
+      if (!usage) {
+        return null;
+      }
+      // A budget alerts like the context widgets: caution, then danger.
+      const thresh = resolveContextThresholds(widget, config);
+      const level =
+        usage.pct === null
+          ? "normal"
+          : usage.pct >= thresh.crit
+            ? "crit"
+            : usage.pct >= thresh.warn
+              ? "warn"
+              : "normal";
+      const color =
+        level === "crit" ? palette.quotaCrit : level === "warn" ? palette.quotaHigh : palette.text;
+      const blinkSeq = !ascii && shouldBlink(level, thresh.blink) ? BLINK : "";
+      return blinkSeq + fg(palette.text) + tag() + fg(color) + usage.text + RESET;
+    }
+
     case "customText": {
       if (!widget?.text) {
         return null;
@@ -491,7 +589,7 @@ function buildLinesSegment(id, session, palette, emojis, ascii = false, widget =
       // buildLinesRows already swapped the widget's color into the palette.
       const col = palette.location;
       const iconPart = emojis && icon && !raw ? `${icon} ` : "";
-      return fg(col) + iconPart + named + output + RESET;
+      return fg(col) + iconPart + named + restoreAfterReset(output, fg(col)) + RESET;
     }
 
     default:
@@ -530,10 +628,22 @@ function buildLinesRows(session, config, palette, emojis, ascii = false, colors
   rowDefs.push(currentRowDef);
 
   const rows = [];
+  const gradient = colors ? gradientStops(config?.gradient) : null;
+  const background = terminalBackground(colors);
+
+  function renderItem(widget, widgetPal) {
+    const item = buildLinesSegment(widget.id, session, widgetPal, emojis, ascii, widget, config);
+    // Bold has to survive the resets inside the segment.
+    return item && widget.bold === true
+      ? BOLD + item.split(RESET).join(RESET + BOLD) + RESET
+      : item;
+  }
 
   for (const def of rowDefs) {
     const groups = [];
     let currentGroup = [];
+    // The widgets shown in this row, so a gradient spreads over exactly those.
+    const placed = [];
 
     function flushGroup() {
       if (currentGroup.length) {
@@ -552,26 +662,35 @@ function buildLinesRows(session, config, palette, emojis, ascii = false, colors
         continue;
       }
 
-      const item = buildLinesSegment(
-        widget.id,
-        session,
-        widgetPalette(widget, palette, colors),
-        emojis,
-        ascii,
-        widget,
-        config
-      );
+      const item = renderItem(widget, widgetPalette(widget, palette, colors));
 
       if (item) {
-        // Bold has to survive the resets inside the segment.
-        currentGroup.push(
-          widget.bold === true ? BOLD + item.split(RESET).join(RESET + BOLD) + RESET : item
-        );
+        placed.push({ widget, group: currentGroup, index: currentGroup.length });
+        currentGroup.push(item);
       }
     }
 
     flushGroup();
 
+    // Each widget's text takes its step of the gradient, made readable on the
+    // terminal background; alert colors and a widget's own color stay.
+    if (gradient && placed.length) {
+      const shades = gradientColors(gradient, placed.length);
+      placed.forEach(({ widget, group, index }, i) => {
+        if (resolveColor(widget.color, colors)) {
+          return;
+        }
+        const shade = withContrast(shades[i], background);
+        const item = renderItem(
+          widget,
+          widgetPalette({ ...widget, color: shade }, palette, colors)
+        );
+        if (item) {
+          group[index] = item;
+        }
+      });
+    }
+
     if (groups.length) {
       rows.push(groups);
     }

package/src/lib/layouts/pills.js

@@ -7,11 +7,15 @@ const {
   bgDefault,
   fg,
   BOLD,
+  DIM,
   NORMAL,
   BLINK,
   BLINK_OFF,
   getActiveDepth,
+  gradientColors,
+  readableText,
 } = require("../colors");
+const { gradientStops } = require("../themes");
 const { pickGlyph, glyphChar } = require("../powerline");
 const {
   quotaColor,
@@ -23,7 +27,11 @@ const {
   formatContextTokens,
   shortModelName,
   formatTokenSplit,
+  formatUsage,
   formatGitSync,
+  formatGitOperation,
+  gitChangeParts,
+  gitFileParts,
   formatTasks,
   formatMode,
   clipText,
@@ -35,12 +43,15 @@ const {
   paceIndex,
   paceGlyph,
 } = require("../formatters");
-const { execWidgetOutput } = require("../exec");
+const { execWidgetOutput, restoreAfterReset } = require("../exec");
 const {
+  resolveColor,
   widgetColors,
   widgetTag,
   isRaw,
   isPaced,
+  METER_STYLES,
+  meterStyle,
   hasNoData,
   RAM_CAUTION,
   RAM_DANGER,
@@ -56,6 +67,9 @@ function fillMeter(pct, width, fillColor, emptyColor, segmentColor, pace = {}) {
   const ratio = Math.max(0, Math.min(100, Number(pct))) / 100;
   const used = Math.round(ratio * width);
   const marker = paceIndex(pace.elapsedPct, width);
+  if (METER_STYLES[pace.style]) {
+    return glyphMeter(used, marker, width, METER_STYLES[pace.style], pace);
+  }
   // The fill is a background color; without color it is drawn with glyphs.
   const plain = getActiveDepth() === "none";
   const glyph = (filled) => (!plain ? " " : pace.ascii ? (filled ? "#" : "-") : filled ? "█" : "░");
@@ -73,6 +87,31 @@ function fillMeter(pct, width, fillColor, emptyColor, segmentColor, pace = {}) {
   return meter + bg(segmentColor);
 }
 
+// A glyph style draws on the pill's own color, with no cells: filled glyphs in
+// the pill's text color (readable on the pill, gradients included), empty
+// ones in the same color dimmed. ASCII mode keeps # and -.
+function glyphMeter(used, marker, width, [full, empty], { ascii, textColor }) {
+  let meter = fg(textColor);
+  let dim = false;
+
+  for (let i = 0; i < width; i++) {
+    const blank = i !== marker && i >= used;
+    if (blank !== dim) {
+      meter += blank ? DIM : NORMAL;
+      dim = blank;
+    }
+    if (i === marker) {
+      meter += paceGlyph(ascii);
+    } else if (ascii) {
+      meter += blank ? "-" : "#";
+    } else {
+      meter += blank ? empty : full;
+    }
+  }
+
+  return dim ? meter + NORMAL : meter;
+}
+
 function meterSegment(
   color,
   pct,
@@ -437,14 +476,52 @@ function buildSegment(id, session, colors, emojis, ascii = false, widget = {}, c
         return null;
       }
       const mark = session.git.dirty ? `${ascii ? "* " : "● "}` : "";
+      const opStr = widget.operation === false ? "" : formatGitOperation(session.git.operation);
+      const opPart = opStr ? `|${opStr}` : "";
       const syncStr = formatGitSync(session.git.ahead, session.git.behind, ascii);
       const syncPart = syncStr ? ` ${syncStr}` : "";
       return pill(
         session.git.dirty ? colors.gitDirty : colors.git,
-        lbl(`${mark}${session.git.branch}${syncPart}`)
+        lbl(`${mark}${session.git.branch}${opPart}${syncPart}`)
       );
     }
 
+    case "gitChanges": {
+      const parts = gitChangeParts(session.gitDetails?.changes, ascii);
+      if (!parts.length) {
+        return null;
+      }
+      return pill(colors.git, lbl(parts.map((part) => part.text).join(" ")));
+    }
+
+    case "gitFiles": {
+      const files = session.gitDetails?.files;
+      const parts = gitFileParts(files, ascii);
+      if (!parts.length) {
+        return null;
+      }
+      const color = files.conflicts > 0 ? colors.gitDirty : colors.git;
+      return pill(color, lbl(parts.map((part) => part.text).join(" ")));
+    }
+
+    case "gitSha":
+      if (!session.gitDetails?.sha) {
+        return null;
+      }
+      return pill(colors.git, lbl(session.gitDetails.sha));
+
+    case "gitStash":
+      if (!(session.gitDetails?.stash > 0)) {
+        return null;
+      }
+      return pill(colors.git, lbl(String(session.gitDetails.stash)));
+
+    case "gitWorktree":
+      if (!session.gitDetails?.worktree) {
+        return null;
+      }
+      return pill(colors.git, lbl(session.gitDetails.worktree));
+
     case "plan":
       if (!session.plan) {
         return null;
@@ -547,6 +624,32 @@ function buildSegment(id, session, colors, emojis, ascii = false, widget = {}, c
         )
       );
 
+    case "tokensToday":
+    case "tokensWeek": {
+      const usage = formatUsage(
+        session.usage?.[id === "tokensToday" ? "today" : "week"],
+        widget,
+        ascii
+      );
+      if (!usage) {
+        return null;
+      }
+      if (usage.pct === null) {
+        return pill(colors.meta, lbl(usage.text));
+      }
+      // A budget alerts like the context widgets: caution, then danger.
+      const thresh = resolveContextThresholds(widget, config);
+      const level =
+        usage.pct >= thresh.crit ? "crit" : usage.pct >= thresh.warn ? "warn" : "normal";
+      const color = contextColor(usage.pct, colors.meta, false, {
+        crit: thresh.crit,
+        warn: thresh.warn,
+        critColor: colors.warn,
+        warnColor: colors.caution,
+      });
+      return pill(color, lbl(usage.text), !ascii && shouldBlink(level, thresh.blink));
+    }
+
     case "customText": {
       if (!widget?.text) {
         return null;
@@ -573,11 +676,58 @@ function buildSegment(id, session, colors, emojis, ascii = false, widget = {}, c
   }
 }
 
+// Pill text on a gradient color that the theme's text doesn't read on.
+const READABLE_TEXT = [[22, 22, 28], WHITE, [0, 0, 0]];
+
 function buildRows(session, config, colors) {
   const rows = [];
   let groups = [];
   let current = [];
+  // The widgets shown in the current row, so a gradient can be spread over
+  // exactly those once the row is complete.
+  let placed = [];
   const splitEveryWidget = !config.powerline.enabled;
+  const gradient = gradientStops(config.gradient);
+
+  function styledSegment(widget, ownColors) {
+    const segment = buildSegment(
+      widget.id,
+      session,
+      ownColors,
+      config.emojis,
+      config.ascii === true,
+      widget,
+      config
+    );
+    if (segment) {
+      segment.textColor = ownColors.text;
+      segment.bold = widget.bold !== false;
+      if (segment.meter) {
+        segment.style = meterStyle(widget, config, "pills");
+      }
+    }
+    return segment;
+  }
+
+  // Each widget takes its step of the gradient in place of its identity
+  // color; alert colors and a widget's own color stay as they are.
+  function applyGradient() {
+    const shades = gradientColors(gradient, placed.length);
+    placed.forEach(({ widget, group, index }, i) => {
+      if (resolveColor(widget.color, colors)) {
+        return;
+      }
+      const ownColors = widgetColors({ ...widget, color: shades[i] }, colors);
+      const segment = styledSegment(widget, ownColors);
+      if (!segment) {
+        return;
+      }
+      if (!resolveColor(widget.textColor, colors)) {
+        segment.textColor = readableText(segment.color, ownColors.text, READABLE_TEXT);
+      }
+      group[index] = segment;
+    });
+  }
 
   function flushGroup() {
     if (current.length) {
@@ -589,6 +739,11 @@ function buildRows(session, config, colors) {
   function flushRow() {
     flushGroup();
 
+    if (gradient && placed.length) {
+      applyGradient();
+    }
+    placed = [];
+
     if (groups.length) {
       rows.push(groups);
       groups = [];
@@ -606,28 +761,18 @@ function buildRows(session, config, colors) {
       continue;
     }
 
-    const ownColors = widgetColors(widget, colors);
-    const segment = buildSegment(
-      widget.id,
-      session,
-      ownColors,
-      config.emojis,
-      config.ascii === true,
-      widget,
-      config
-    );
+    const segment = styledSegment(widget, widgetColors(widget, colors));
 
     if (!segment) {
       continue;
     }
 
-    segment.textColor = ownColors.text;
-    segment.bold = widget.bold !== false;
+    const group = splitEveryWidget ? [] : current;
+    placed.push({ widget, group, index: group.length });
+    group.push(segment);
 
     if (splitEveryWidget) {
-      groups.push([segment]);
-    } else {
-      current.push(segment);
+      groups.push(group);
     }
   }
 
@@ -674,7 +819,9 @@ function segmentContent(text, color, textColor, blink = false, bold = true) {
   const blinkSeq = blink ? BLINK : "";
   const blinkOff = blink ? BLINK_OFF : "";
   // NORMAL clears bold left over from a previous widget.
-  return bg(color) + fg(textColor) + blinkSeq + (bold ? BOLD : NORMAL) + text + blinkOff;
+  const style = bg(color) + fg(textColor) + blinkSeq + (bold ? BOLD : NORMAL);
+  // Only exec output with "colors": true still holds escapes here.
+  return style + (text.includes("\x1b") ? restoreAfterReset(text, style) : text) + blinkOff;
 }
 
 function renderMeterSegment(segment, colors, ascii = false) {
@@ -685,6 +832,8 @@ function renderMeterSegment(segment, colors, ascii = false) {
   const meter = fillMeter(displayPct, 12, segment.fill, segment.empty, segment.color, {
     elapsedPct: segment.elapsedPct,
     ascii,
+    style: segment.style,
+    textColor,
   });
   const bold = segment.bold !== false;