@tiens.nguyen/gu-cli 1.0.782 → 1.0.784

package/preset-editor.mjs

@@ -11,7 +11,7 @@
  *     user's own 0600 file; root would make it root-owned and ask for a password for nothing.
  *   · The temp file holds a live key: it is created 0600 inside a private 0700 directory and the
  *     directory is removed on every path out, a Ctrl+C included.
- *   · /load-presets can show a preset as one framed block — the key MASKED on screen (scrollback
+ *   · /use-presets could show a preset as one framed block — the key MASKED on screen (scrollback
  *     and logs must not keep it, #248) — and copy it with the real key: as the ready-to-paste
  *     `/save-preset <name> {…}` command (paste it into gu on another computer and it is there),
  *     or as plain JSON.
@@ -52,8 +52,9 @@ export function isHeadless({ env = process.env, platform = process.platform } =
  * `saveHint` is what the header tells the person to press — editors differ, and a server's nano is
  * often someone's first.
  */
-export function pickEditor({ env = process.env, platform = process.platform, has = onPath } = {}) {
+export function pickEditor({ env = process.env, platform = process.platform, has = onPath, readOnly = false } = {}) {
   const headless = isHeadless({ env, platform });
+  const withHints = (ed) => editorHints(ed, { readOnly, platform });
   const named = [env.VISUAL, env.EDITOR].map(splitCommand).filter((w) => w.length);
   for (const words of named) {
     const base = words[0].split(/[\\/]/).pop();
@@ -65,8 +66,30 @@ export function pickEditor({ env = process.env, platform = process.platform, has
   return null;
 }
 
-function withHints(ed) {
+/**
+ * The flags and the "how do I save" line for one editor.
+ *
+ * READ-ONLY (#322, /open-presets with no name — the current setup, to copy to another computer):
+ * nano -v (view mode), vim/vi -R. And for nano, SOFT-WRAP (-$): nano otherwise shows a long line cut
+ * off at the screen edge, and a key copied from an 80-column SSH terminal would come out SHORTER —
+ * a key that looks fine and is wrong. (Not macOS's /usr/bin/nano, which is pico and has no -$; the
+ * line breaks a soft-wrapped copy carries are taken out again by parseEdited.)
+ */
+function editorHints(ed, { readOnly = false, platform = process.platform } = {}) {
   const base = ed.cmd.split(/[\\/]/).pop().replace(/\.exe$/i, "").toLowerCase();
+  if (readOnly) {
+    let args = ed.args;
+    if (base === "nano") {
+      if (!args.includes("-v") && !args.includes("--view")) args = ["-v", ...args];
+      if (platform !== "darwin" && !args.some((a) => a === "-$" || a === "--softwrap")) args = ["-$", ...args];
+    } else if (/^(vim?|nvim|gvim)$/.test(base) && !args.includes("-R")) args = ["-R", ...args];
+    const closeHint =
+      base === "nano" ? "nano: Ctrl+X to close"
+      : /^(vim?|nvim|gvim)$/.test(base) ? "vi: :q Enter to close"
+      : base === "notepad" ? "Notepad: close the window (nothing you change is kept)"
+      : "quit the editor (nothing you change is kept)";
+    return { ...ed, args, saveHint: closeHint, readOnly: true };
+  }
   if (base === "nano" && !ed.args.some((a) => /^(-w|--nowrap|-b|--breaklonglines)$/.test(a))) ed = { ...ed, args: ["-w", ...ed.args] };
   const saveHint =
     base === "nano" ? "nano: Ctrl+O, Enter, Ctrl+X to save · Ctrl+X, N to cancel"
@@ -77,6 +100,47 @@ function withHints(ed) {
   return { ...ed, saveHint };
 }
 
+/**
+ * Take raw line breaks out of JSON STRINGS (never out of the structure between them). Only strings
+ * are touched, and a valid JSON string cannot contain a raw line break — so valid JSON is unchanged.
+ */
+export function joinBrokenStrings(src) {
+  let out = "";
+  let inStr = false;
+  for (let i = 0; i < src.length; i++) {
+    const c = src[i];
+    if (inStr) {
+      if (c === "\\") {
+        out += c + (src[i + 1] ?? "");
+        i++;
+        continue;
+      }
+      if (c === "\r" || c === "\n") continue;
+      if (c === '"') inStr = false;
+    } else if (c === '"') inStr = true;
+    out += c;
+  }
+  return out;
+}
+
+/**
+ * /open-presets with no name (#322): THE CURRENT SETUP, read-only, to copy to another computer and
+ * paste into /save-preset there. The full keys are in it — that is the point — so the header says so.
+ */
+export function currentSetupText(doc) {
+  const { note: _n, savedAt: _a, savedOn: _o, ...body } = doc ?? {};
+  return (
+    [
+      "// Your gu setup NOW — read-only. Copy ALL of it (keys included) and on the",
+      "// other computer run /save-preset there, paste it, save and quit.",
+      "// This CONTAINS your API keys — paste it only somewhere private.",
+    ].join("\n") +
+    "\n" +
+    JSON.stringify({ ...body, gu: "preset", version: FULL_PRESET_VERSION }, null, 2) +
+    "\n"
+  );
+}
+
 /** What to say when a server has no editor at all. */
 export const NO_EDITOR_HINT = "no editor found — install one (Ubuntu: sudo apt install nano) or set $EDITOR";
 
@@ -122,9 +186,11 @@ export function editorText(name, preset = {}) {
     const { note: _n, savedAt: _a, savedOn: _o, ...body } = preset;
     return (
       [
-        `// gu preset "${name}" — THE WHOLE SETUP: every coding server and its models, each server's API key,`,
-        "// the default coder, the agent and the embedder. Edit anything, then save and quit to store it.",
-        "// Lines starting with // are ignored. Quit without saving (or unchanged) to cancel. This CONTAINS your API keys.",
+        // each line fits an 80-column SSH terminal (#322)
+        `// gu preset "${name}" — servers, models, API keys, coder, agent, embedder.`,
+        "// Edit anything, then save and quit to keep it (it is checked first).",
+        "// Quit without saving to leave it as it is. Lines starting // are ignored.",
+        "// This CONTAINS your API keys.",
       ].join("\n") +
       "\n" +
       JSON.stringify({ ...body, gu: "preset", version: FULL_PRESET_VERSION, name }, null, 2) +
@@ -221,11 +287,23 @@ export function jsonErrorIndex(src) {
  * blanked (not removed) so a JSON error's line number is the line the person sees in the editor.
  */
 export function parseEdited(text) {
-  const src = String(text ?? "").replace(/^[ \t]*\/\/.*$/gm, "");
+  let src = String(text ?? "").replace(/^[ \t]*\/\/.*$/gm, "");
   if (!src.trim()) return { ok: false, empty: true, problem: "the file is empty." };
   try {
     JSON.parse(src);
   } catch (e) {
+    // A copy from a soft-wrapping terminal or editor breaks a long line — a key — in two (#322). A
+    // JSON string can never hold a raw line break, so taking them out of strings changes nothing
+    // that was valid; it is only tried when the text does not parse as it is.
+    const joined = joinBrokenStrings(src);
+    if (joined !== src) {
+      try {
+        JSON.parse(joined);
+        return parseEdited(joined);
+      } catch {
+        /* still broken — report the ORIGINAL text's mistake, at the line the person sees */
+      }
+    }
     // Node names the line only for SOME errors ("Expected ':' …"); a stray comma comes back as just a
     // snippet. So when it does not say, find the spot ourselves — the person fixes a LINE in an editor.
     let at = /line (\d+) column (\d+)/.exec(String(e?.message ?? ""));
@@ -301,7 +379,7 @@ export function presetCopyJson(preset) {
 }
 
 /**
- * The framed block /load-presets prints for "view": the key masked, "⧉ copy" in the top border.
+ * The framed block a preset view prints for "view": the key masked, "⧉ copy" in the top border.
  * Every row fits `width - 1` so none wraps (a wrapped row breaks the click arithmetic, #109).
  * → { rows, button: { from, to } } — the button's column span on row 0, 0-based, gutter included.
  */
@@ -325,10 +403,10 @@ export function presetBlock(name, preset, { width = 80, gutter = "   " } = {}) {
   };
 }
 
-/** The keys the /load-presets picker takes, in the order its hint line names them. */
-export const PICKER_KEYS = { v: "view", c: "copy", j: "json", e: "edit" };
+/** The keys the /use-presets picker takes, in the order its hint line names them. */
+export const PICKER_KEYS = { o: "open" };
 // Short enough for one 80-column row with "  Presets in ~  (…):" around it (#322 — it wrapped).
-export const PICKER_HINT = "Enter use · v view · c copy · j JSON · e edit · Esc";
+export const PICKER_HINT = "Enter use it · o open in the editor · Esc";
 
 /**
  * The file the editor opens for "paste a preset" (#322: "load preset doesn't give me any editor so
@@ -347,7 +425,7 @@ export function pasteTemplate(saveHint = "save, then quit the editor") {
 }
 
 /**
- * A PRESET SOMEONE ALREADY HAS, pasted into /load-presets (#317: "I need a place to input a preset
+ * A PRESET SOMEONE ALREADY HAS, pasted into /save-preset (#317: "I need a place to input a preset
  * I have already, which is in JSON format"). Three shapes are accepted, because those are the three
  * things a person could be holding:
  *

package/presets-transfer.mjs

@@ -1,5 +1,5 @@
 /**
- * MODEL PRESETS — the files /save-preset writes and /load-presets reads (#6).
+ * MODEL PRESETS — the files /save-preset writes and /use-presets reads (#6).
  *
  * HOW A PRESET DIFFERS FROM A SETTINGS FILE. /save-settings asks nothing: it writes the whole
  * account, names the keys, and refuses to carry a single secret. /save-preset is the opposite
@@ -15,7 +15,7 @@
  * preset's name, bound to that row, and made the row's DEFAULT key so the resolver finds it.
  *
  * THE MARKER. A preset file carries "gu": "preset" (not "settings") so /load-settings never
- * offers it and /load-presets never offers a settings file — two commands, two folders' worth of
+ * offers it and /use-presets never offers a settings file — two commands, two folders' worth of
  * files, no cross-picking.
  */
 
@@ -56,7 +56,7 @@ export function presetFilePath(typed, home) {
 const withJson = (p) => (extname(basename(p)) ? p : `${p}.json`);
 
 /**
- * The preset files in the default folder, newest first — what /load-presets offers. Only files
+ * The preset files in the default folder, newest first — what /use-presets offers. Only files
  * that ARE preset files (the "gu": "preset" marker). `entries` = [{ name, text, mtimeMs }], and
  * each name is returned as just the preset name (the .json comes off — it is the name the user
  * typed when saving).
@@ -198,7 +198,7 @@ export function presetToSettingsPatch(preset, current = {}) {
   };
 }
 
-/** The lines /load-presets prints before it asks — what applying the preset will do. */
+/** The lines /use-presets prints before it asks — what applying the preset will do. */
 export function presetPlanLines(name, preset, current = {}) {
   const same = (a, b) => clean(a).toLowerCase() === clean(b).toLowerCase();
   const lines = [];
@@ -409,7 +409,7 @@ export function maskedFullPreset(doc) {
   return { ...doc, keys: (Array.isArray(doc?.keys) ? doc.keys : []).map((k) => ({ ...k, ...(k.key ? { key: mask(k.key) } : {}) })) };
 }
 
-/** The lines /load-presets prints before applying a version-2 preset (keys masked). */
+/** The lines /use-presets prints before applying a version-2 preset (keys masked). */
 export function fullPresetSummary(v, codingDefault) {
   const lines = [];
   for (const b of v.backends) {

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);