@tiens.nguyen/gu-cli 1.0.783 → 1.0.785

package/step-tokens.mjs

@@ -53,3 +53,48 @@ export function readStepTokens(breakdown) {
   const n = (v) => (Number.isFinite(Number(v)) && Number(v) > 0 ? Number(v) : 0);
   return { step, stepIn: n(breakdown.liveStepIn), stepOut: n(breakdown.liveStepOut) };
 }
+
+// ---------------------------------------------------------------------------------------------
+// WHAT THE TURN COST needs two more figures (#323), riding the same breakdown for the same reason:
+//   · liveCached / liveCacheReported — the prompt tokens the provider served from its cache, summed
+//     over the turn (python's `codeCached`, present ONLY when the provider reported a count);
+//   · liveFirstIn — the first step's prompt: nothing is cached on it, so when the provider reports
+//     nothing, gu assumes 90% of every LATER step was cached (model-prices.mjs).
+// ---------------------------------------------------------------------------------------------
+
+/** The turn's cache figures before any event. */
+export const NO_CACHE = Object.freeze({ cached: 0, cacheReported: false, firstIn: 0, firstStep: 0 });
+
+/** Fold one python "tokens" event into the turn's cache figures. */
+export function foldTurnCache(prev, event) {
+  let { cached, cacheReported, firstIn, firstStep } = prev ?? NO_CACHE;
+  if (!event || typeof event !== "object") return { cached, cacheReported, firstIn, firstStep };
+  if (Number.isFinite(event.codeCached) && event.codeCached >= 0) {
+    cacheReported = true;
+    if (event.codeCached > cached) cached = event.codeCached;
+  }
+  const step = Number.isFinite(event.step) ? event.step : 0;
+  if (step > 0 && (firstStep === 0 || step < firstStep)) {
+    firstStep = step;
+    firstIn = 0;
+  }
+  if (step > 0 && step === firstStep && Number.isFinite(event.stepInput) && event.stepInput > firstIn) firstIn = event.stepInput;
+  return { cached, cacheReported, firstIn, firstStep };
+}
+
+/** The breakdown, carrying the turn's cache figures. */
+export function withTurnCache(breakdown, c) {
+  if (!breakdown || typeof breakdown !== "object" || !c) return breakdown;
+  return {
+    ...breakdown,
+    liveFirstIn: c.firstIn,
+    ...(c.cacheReported ? { liveCached: c.cached, liveCacheReported: true } : {}),
+  };
+}
+
+/** What the terminal reads back: { cached, cacheReported, firstIn }, or null from an older worker. */
+export function readTurnCache(breakdown) {
+  if (!breakdown || typeof breakdown !== "object" || !("liveFirstIn" in breakdown)) return null;
+  const n = (v) => (Number.isFinite(Number(v)) && Number(v) > 0 ? Number(v) : 0);
+  return { cached: n(breakdown.liveCached), cacheReported: breakdown.liveCacheReported === true, firstIn: n(breakdown.liveFirstIn) };
+}

package/terminal-layout.mjs

@@ -2852,3 +2852,17 @@ export function noticeRow(items, { width = 80, gutter = "   ", sep = "  ·  " }
   });
   return { row, spans };
 }
+
+/**
+ * THE TURN'S PRICE AT THE END OF THE TOKEN ROW (#323): "↑ sent 500k · ↓ out 4.3k · total ↓ 1.6M | ~$0.33".
+ *
+ * The row is clipped on the RIGHT at the window's width, and the price is the last thing on it — so
+ * on a narrow window (80 columns over SSH) it would be the first thing lost. When the whole row does
+ * not fit, the lifetime "total ↓" goes first (it changes no decision about this turn); the price
+ * stays. `price` = the already-painted " | ~$0.33" segment, or "" when the model has no price.
+ */
+export function tokenRowWithPrice({ withTotal = "", withoutTotal = "", price = "", room = 80 } = {}) {
+  if (!price) return withTotal;
+  if (visibleLen(withTotal) + visibleLen(price) <= room) return withTotal + price;
+  return withoutTotal + price;
+}

package/terminal-viewport.mjs

@@ -674,3 +674,68 @@ export function applySelectionHighlight(rows, sel, sgr = SELECTION_SGR) {
     return highlightRow(row, from, to, sgr);
   });
 }
+
+/**
+ * WHEN THE FROZEN ZONE CHANGES HEIGHT (#321) — move the screen the way a terminal would, instead of
+ * repainting it from the transcript.
+ *
+ * Reported: after an update, the banner and the update notice appeared again and again in the
+ * scrollback, and single lines ("auto-test off", "1 skill · 1 MCP server") were doubled. The cause
+ * was the repaint that followed every height change of the bottom zone (a picker, the notice row,
+ * the status block coming and going):
+ *   · the zone SHRANK → the region grew → the repaint filled the new rows at the TOP with older
+ *     transcript lines — lines the terminal had ALREADY scrolled into its scrollback. The next
+ *     output scrolled them in again: one more copy per shrink;
+ *   · the zone GREW → the repaint painted over the top rows, which never reached the scrollback.
+ *
+ * Now:
+ *   · GROW by k: the k rows the zone takes come out of the blank rows below the content first; for
+ *     the rest, the region is scrolled up (real newlines), so the top lines go into the scrollback
+ *     ONCE, the normal way;
+ *   · SHRINK by k: the content stays where it is and the k freed rows are cleared; they are
+ *     remembered as blank rows below the content ("pad"), which new output fills first.
+ * gu's model of the screen is the transcript's rows plus `pad` blank rows, bottom-aligned once it
+ * fills the region and top-aligned before (viewportSlice), so it matches without a repaint.
+ *
+ * → { scrollUp, clearRows, pad }: lines to scroll the OLD region up by, rows to clear below the old
+ *   region (the freed rows), and the new pad.
+ */
+export function zoneResizePlan({ contentRows = 0, pad = 0, oldHeight, newHeight }) {
+  const c = Math.max(0, contentRows | 0);
+  const p = Math.max(0, pad | 0);
+  const oldH = Math.max(1, oldHeight | 0);
+  const newH = Math.max(1, newHeight | 0);
+  const full = c + p >= oldH; // bottom-aligned (the region is full) vs top-aligned
+  if (newH >= oldH) {
+    const k = newH - oldH;
+    return { scrollUp: 0, clearRows: k, pad: full ? p + k : p };
+  }
+  const k = oldH - newH;
+  const blanks = full ? p : oldH - c; // rows at the bottom holding nothing
+  const fromBlank = Math.min(blanks, k);
+  const scrollUp = k - fromBlank;
+  if (scrollUp > 0) return { scrollUp, clearRows: 0, pad: 0 };
+  return { scrollUp: 0, clearRows: 0, pad: full ? p - fromBlank : Math.max(0, Math.min(p, newH - c)) };
+}
+
+/**
+ * A BLOCK DRAWN BELOW THE CONTENT AND WIPED AGAIN — a picker (#321). Its rows are not transcript
+ * content, but drawing them can scroll the region: whatever scrolled away is in the terminal's
+ * scrollback now. Wiping the block leaves the content shifted up by that much with blank rows under
+ * it — recorded as pad, so no later repaint brings the scrolled-away lines back (each one would
+ * land in the scrollback a second time).
+ *   contentRows  the transcript's rows when the block was first drawn (its last is the cursor row)
+ *   pad          the blank rows below the content then (gu's pad)
+ *   height       the region's rows
+ *   blockRows    the most physical rows the block drew (it ends with a newline)
+ * → the pad after the wipe.
+ */
+export function blockClosedPad({ contentRows = 0, pad = 0, height, blockRows = 0 }) {
+  const c = Math.max(0, contentRows | 0);
+  const p = Math.max(0, pad | 0);
+  const h = Math.max(1, height | 0);
+  const full = c + p >= h;
+  const blanks = full ? p : h - c; // rows below the cursor row's region that hold nothing
+  const scrolled = Math.max(0, (blockRows | 0) - blanks);
+  return full || scrolled > 0 ? blanks + scrolled : p;
+}

package/turn-stop.mjs

@@ -55,6 +55,23 @@ export function replaceStoppedQuestion(history, oldTask, newTask) {
   return true;
 }
 
+/**
+ * Has the user LET GO of the restored question? (task #247 meets #302)
+ *
+ * The line going EMPTY is "never mind", however it was emptied — Ctrl+C, Backspace, Ctrl+U, a
+ * picker taking the line. Only Ctrl+C used to count, so erasing the question and typing "where
+ * were we?" was taken for an EDIT of it: the message replaced the stopped question in history and
+ * the model was asked where we were with nothing before it — the report #247 began with.
+ * What is typed after that is a new message; the stopped question stays, tagged "still stands".
+ *
+ * Enter is not an emptying: readline has already cleared the line it is submitting by the time
+ * the keypress is seen.
+ */
+export function restoredQuestionLetGo(line, key) {
+  if (key && (key.name === "return" || key.name === "enter")) return false;
+  return String(line ?? "") === "";
+}
+
 /** Short relative names for the stop note: the last two path parts. */
 function shortPath(p) {
   const parts = String(p ?? "").split(/[\\/]/).filter(Boolean);