@tiens.nguyen/gu-cli 1.0.868 → 1.0.870

package/gonext_agent_chat.py

@@ -10442,10 +10442,7 @@ def run_agent_chat(cfg):
         # wrong python" — indistinguishable, and both were hit while getting a client working.
         import platform as _plat  # noqa: PLC0415
         _where = f"{_plat.node()} · {sys.executable}"
-        _emit({"type": "final",
-               "text": f"[smolagents not installed on {_where}: {e}]\n"
-                       f"Fix on THAT machine: {sys.executable} -m pip install -U smolagents openai\n"
-                       f"then: gu stop && gu start"})
+        _emit({"type": "final", "text": _smolagents_missing_text(_where, e, sys.executable, sys.version_info)})
         _log(f"smolagents import FAILED on {_where}: {e}")
         return
     _patch_dotted_imports()
@@ -17077,6 +17074,27 @@ def _request_dump_range(n_msgs: int) -> tuple:
 _EMIT_LOCK = threading.Lock()
 
 
+def _smolagents_missing_text(where, err, exe, ver):
+    """The turn's message when `import smolagents` fails (reported on a Windows 11 customer, #232).
+
+    Names the exception TYPE (a missing module and a broken dependency need different fixes), says
+    when this Python is too new for prebuilt wheels (> 3.14: pip then tries to compile PyYAML and
+    fails without Visual C++), and leads with `gu doctor`, which installs into the interpreter the
+    background worker actually uses and pins it - a bare pip line can put the packages somewhere
+    else."""
+    kind = type(err).__name__
+    lines = [f"[smolagents could not be loaded on {where}: {kind}: {err}]"]
+    if (ver[0], ver[1]) > (3, 14):
+        lines.append(f"This Python is {ver[0]}.{ver[1]}: too new for the packages' prebuilt wheels, so pip "
+                     f"cannot install them. Install Python 3.13 (Windows: winget install Python.Python.3.13), "
+                     f"open a new terminal, then run: gu doctor")
+    else:
+        lines.append("Fix: run `gu doctor` (it installs smolagents + openai into the Python the worker uses), "
+                     "then: gu stop && gu start")
+        lines.append(f"By hand, on THAT machine: {exe} -m pip install -U smolagents openai")
+    return "\n".join(lines)
+
+
 def _emit(obj):
     """Write one NDJSON line to the real stdout and flush immediately.
 

package/gu-repl.mjs

@@ -157,6 +157,7 @@ import { globalPrefixOf } from "./install-path.mjs";
 import { indentBlock, commandBlockRows } from "./terminal-layout.mjs"; // every line of an Allow-prompt detail indented (#189); wrapped + collapsible command (#204)
 import { firstGuOnPath, pathGuMismatch, guOnPathIsCurrent, updateAttemptRecord, repeatUpdateNotice } from "./update-verify.mjs";
 import { embedNotice, embedState, setupNoticeRows } from "./embed-model-command.mjs";
+import { normalizeQuick, quickReady, quickTarget, quickBarHint, quickWarning, QUICK_MAX } from "./quick-models.mjs";
 import {
   MODELFALLBACK_PREFIX, fallbackAfterTurn, fallbackHistoryLine, fallbackNotice, keyMissingNotice,
   parseModelFallback,
@@ -991,6 +992,7 @@ const COMMANDS = [
   // "/model" has meant the CODING model since task #44, and "agent model" vs "agent coding model"
   // has already confused the person who built both. The descriptions carry the distinction.
   { name: "/model", desc: "switch the CODING model (the one that writes code) for this session" },
+  { name: "/quick-models", desc: "pick up to 2 coding models to flip between with ← / → at the prompt" },
   // /provider IS NOT LISTED HERE ANY MORE — see HIDDEN_COMMANDS. It was promoted to a top-level
   // command when editing a provider was genuinely unreachable, and by the very next change
   // /model carried "add or change a provider — Claude API, OpenAI, Kimi…" as a row in EVERY branch of
@@ -1855,6 +1857,7 @@ const fallbackNoticeRows = () => {
     ...(codingKeyMissingKnown === true
       ? [keyMissingNotice({ coder: activeCodingModelId(), width, gutter: GUTTER })]
       : []),
+    ...[quickWarning(quickModels, quickActiveId(), { width, gutter: GUTTER })].filter(Boolean),
   ];
 };
 
@@ -2364,7 +2367,7 @@ function slashCloseSeq(line, cursor, cols) {
 let editMode = "accept"; // "accept" | "manual"
 const modeLineText = () =>
   white("✎ " + (editMode === "accept" ? "accept edits on" : "manually edit")) +
-  dim("   (shift+tab to switch)");
+  dim("   (shift+tab to switch)") + (quickBarHint(quickModels) ? dim("  " + quickBarHint(quickModels)) : "");
 // Token usage for the bar's middle row (task #104): the LAST turn's code-model input +
 // output, then the coder's lifetime output total. Unlike the old per-turn print, this row is
 // ALWAYS on screen — a turn that did no code-model work honestly reads "0", and the lifetime
@@ -4732,6 +4735,14 @@ if (process.stdin.isTTY) {
     if (key && key.ctrl && key.name === "t" && !slashOverlayActive) {
       if (toggleNewestThought()) return;
     }
+    // ← / → at the EMPTY prompt flips between the two quick models (#233). Only at an idle prompt:
+    // not in a question (askWaiting), not during a command or a turn (inputVisible is false then),
+    // not over the slash menu, and never on a line with text — there the arrows move the caret.
+    if (key && (key.name === "left" || key.name === "right") && !key.ctrl && !key.meta && !key.shift
+        && rl.line === "" && inputVisible && !askWaiting && !slashOverlayActive && quickReady(quickModels)) {
+      void quickSwitch();
+      return;
+    }
     // Shift+Tab cycles the edit mode shown in the bottom bar (display-only). Skip while the
     // slash overlay owns the screen so we don't fight its redraw.
     if (key && key.name === "tab" && key.shift) {
@@ -5779,6 +5790,25 @@ async function loadSessionCoding(cwd) {
   }
 }
 
+async function loadQuickModels(cwd) {
+  try {
+    return normalizeQuick(JSON.parse(await readFile(sessionFilePath(cwd), "utf8"))?.quickModels);
+  } catch {
+    return [];
+  }
+}
+
+async function saveQuickModels(cwd) {
+  try {
+    await updateSessionFile(cwd, (raw) => {
+      raw.quickModels = quickModels;
+      raw.updatedAt = new Date().toISOString();
+    });
+  } catch (err) {
+    console.error(dim(`(quick models save failed: ${err.message})`));
+  }
+}
+
 /** This folder's stored choice — the SHAPE reading lives in terminal-layout, where it is
  *  testable; only the file I/O is here. */
 async function loadSessionRagStorage(cwd) {
@@ -7275,6 +7305,76 @@ async function useCoderInThisFolder({ ps, rows, beforeChoices, url, host, locali
   { const g = pickGlobalTotal(t); if (g !== null) globalOutputTokens = g; }
 }
 
+
+/**
+ * The picker rows for a list of coding choices, and the tags that tell same-named ones apart.
+ * Shared by /model and /quick-models (#233) so the two lists read identically.
+ */
+function codingChoiceLabels(choices, def) {
+  const { tags, show: showTag } = codingChoiceTags(choices);
+  const labels = choices.map((c, i) => {
+    // Every row says WHERE it runs in front of the name ("ollama.com/kimi-k3",
+    // "api.anthropic.com/claude-opus-5" — #263), so the kind tag is only for a row with no server.
+    const where = coderWhere(c.kind, c.url);
+    const tag = showTag && !where ? `  ${dim(`· ${tags[i]}`)}` : "";
+    return `${coderDisplayName(c.model, where)}${tag}${c.id === def ? "  (default)" : ""}`;
+  });
+  return { labels, tags, showTag };
+}
+
+/**
+ * /quick-models — tick up to two coding models to flip between with ← / → (#233). The list is the
+ * same (backend, model) choices /model offers, pre-ticked from what is saved; Enter saves, Esc leaves
+ * it as it was.
+ */
+async function chooseQuickModels() {
+  let probe;
+  try {
+    probe = await withPendingStatus("loading models", () => fetchAgentPayload([{ role: "user", content: "ping" }]));
+  } catch (err) {
+    console.log(red(`   ${describeApiFailure(err, "couldn't load models")}\n`));
+    return;
+  }
+  const def = (probe?.codingDefault ?? "").trim();
+  const choices = Array.isArray(probe?.codingChoices) && probe.codingChoices.length
+    ? probe.codingChoices
+    : (Array.isArray(probe?.codingAllowed) ? probe.codingAllowed : []).map((id) => ({ id, model: id, kind: "" }));
+  if (choices.length < 2) {
+    console.log(dim("   Quick models need at least two coding models — add one with /model → add or change a provider.\n"));
+    return;
+  }
+  const { labels } = codingChoiceLabels(choices, def);
+  const pre = quickModels.map((q) => choices.findIndex((c) => c.id === q.id)).filter((i) => i >= 0);
+  console.log(dim(`   Tick up to ${QUICK_MAX} models to flip between with ← / →  (space ticks · Enter saves · Esc cancels):`));
+  const picked = await pickManyFromList(labels, pre, { max: QUICK_MAX });
+  if (picked === null) {
+    console.log(dim("   (cancelled)\n"));
+    return;
+  }
+  quickModels = normalizeQuick(picked.map((i) => choices[i]));
+  await saveQuickModels(resolve(process.cwd()));
+  if (quickModels.length === 0) console.log(dim("   quick models cleared — ← / → does nothing.\n"));
+  else if (quickModels.length === 1) console.log(accent(` ✓ 1 quick model: ${quickModels[0].model}`) + dim(" — pick a second to switch with ← / →\n"));
+  else console.log(accent(` ✓ quick models: ${quickModels.map((c) => c.model).join("  ⇄  ")}`) + dim("   (← / → at the prompt)\n"));
+  paintBar();
+}
+
+/** ← / → at the empty prompt: flip to the other quick model, through the same steps as /model. */
+async function quickSwitch() {
+  if (quickSwitching) return;
+  const target = quickTarget(quickModels, quickActiveId());
+  if (!target) return;
+  quickSwitching = true;
+  try {
+    await applyChosenCoder(target, { quick: true });
+  } catch (e) {
+    if (!wasPromptCancelled(e)) console.log(red(`   quick switch failed: ${e?.message ?? e}\n`));
+  } finally {
+    quickSwitching = false;
+    paintBar();
+  }
+}
+
 async function chooseModel() {
   let probe;
   try {
@@ -7345,14 +7445,7 @@ async function chooseModel() {
   // Which tag tells these rows apart — the kind, or the provider the API derived from each
   // URL. The rule and its reasons live in coding-choice-tags.mjs (task #223): two
   // OpenAI-compatible providers are both "OpenAI-compatible", so the kind names neither.
-  const { tags, show: showTag } = codingChoiceTags(choices);
-  const labels = choices.map((c, i) => {
-    // Every row says WHERE it runs in front of the name ("ollama.com/kimi-k3",
-    // "api.anthropic.com/claude-opus-5" — #263), so the kind tag is only for a row with no server.
-    const where = coderWhere(c.kind, c.url);
-    const tag = showTag && !where ? `  ${dim(`· ${tags[i]}`)}` : "";
-    return `${coderDisplayName(c.model, where)}${tag}${c.id === def ? "  (default)" : ""}`;
-  });
+  const { labels, tags, showTag } = codingChoiceLabels(choices, def);
   const activeIdx = choices.findIndex((c) => c.id === active);
   labels.push("change the Ollama server this machine uses…");
   // Task #223. Appended LAST, after the #220 entry, for the same reason that one is appended
@@ -7384,7 +7477,16 @@ async function chooseModel() {
     else await manageCodingProviders();
     return;
   }
-  const chosen = choices[idx];
+  await applyChosenCoder(choices[idx], { def, tag: showTag ? tags[idx] : "" });
+}
+
+/**
+ * Make `chosen` ({ id, model, kind, url }) the coding model: session state, saved choice, the key
+ * check and the lifetime token total. The tail of /model, extracted so /quick-models' ← / → (#233)
+ * runs EXACTLY the same steps — a quick switch that skipped the key prompt would leave gu on a
+ * coder it cannot use (#181). `quick` only quietens the output: one ✓ line, no key essay.
+ */
+async function applyChosenCoder(chosen, { def = "", tag = "", quick = false } = {}) {
   // Empty override means "use the account default" — so don't send an override when the
   // user picks the default (keeps the payload clean and lets a later default change win).
   // GitHub #130: what to go back to if the key prompt for the new coder is cancelled (Esc).
@@ -7409,7 +7511,7 @@ async function chooseModel() {
   // WRITTEN NOW, not at the end of the next turn: `/model` then `/exit` is how the choice is
   // made and then tested, and that path never reaches saveSession.
   await saveSessionCoding(resolve(process.cwd()));
-  const where = showTag && !activeCoderWhere ? ` (${tags[idx]})` : "";
+  const where = tag && !activeCoderWhere ? ` (${tag})` : "";
   console.log(
     accent(
       ` ✓ coding model → ${coderDisplayName(chosen.model, activeCoderWhere)}${where}${chosen.id === def ? " (default)" : ""}\n`
@@ -7480,7 +7582,7 @@ async function chooseModel() {
       backendId: ks.backendId,
       host: ks.provider,
     });
-    console.log(
+    if (!quick) console.log(
       dim("   API key ") + accent(line.text) +
         (line.note ? orange(`  ·  ${line.note}`) : "") +
         dim(`  ·  ctrl+k to ${line.verb} it`)
@@ -7490,7 +7592,7 @@ async function chooseModel() {
     // the more common one — "how do I change the model" — with no visible answer at all. Reported
     // three times from exactly this view, twice after being told where the picker entry was.
     // /provider is hidden (see HIDDEN_COMMANDS): point at the row of /model that does the same.
-    console.log(dim("   to change this provider's model or URL, or remove it: /model → add or change a provider\n"));
+    if (!quick) console.log(dim("   to change this provider's model or URL, or remove it: /model → add or change a provider\n"));
   }
   // Task #125: the GLOBAL lifetime total is per-backend, so re-fetch it for the newly
   // selected backend NOW — otherwise the footer would keep showing the previous backend's
@@ -11524,6 +11626,16 @@ let jobIdForApprovalRace = "";
 // Task #123: with several backends configured this is a QUALIFIED id ("<kind>::<model>"),
 // which resolves to a whole backend — URL, kind and API key — not just a model name.
 let sessionCodingModel = "";
+// QUICK MODELS (#233): up to two coding choices ({ id, model, kind, url }) that ← / → flips between at
+// the empty prompt. Per folder, in the session file, like the /model pick.
+let quickModels = [];
+let quickSwitching = false;
+/** The id the quick list compares against: the folder's pick, else the account default's choice id. */
+const quickActiveId = () => {
+  if (sessionCodingModel) return sessionCodingModel;
+  const d = quickModels.find((c) => c.id === defaultCodingModel) ?? quickModels.find((c) => c.model === defaultCodingModel);
+  return d ? d.id : defaultCodingModel;
+};
 /**
  * WHICH STORED API KEY THIS FOLDER USES for the coding model (task #222, phase 3).
  *
@@ -13823,6 +13935,7 @@ async function main() {
       sessionEmbedKeyId = await loadSessionFolderKeyId(resolve(process.cwd()), "embed");
     }
   }
+  quickModels = await loadQuickModels(resolve(process.cwd())); // #233 — folder file only, whatever the database said
   // Fetch the API key tail after loading the session, if a key is configured
   if (sessionCodingKeyId) {
     try {
@@ -14765,6 +14878,10 @@ async function main() {
       paintBar();
       continue;
     }
+    if (line === "/quick-models") {
+      await chooseQuickModels();
+      continue;
+    }
     if (line === "/model") {
       await chooseModel();
       await refreshNoModelAtAll(); // #188: a coding model may have just been set → drop its row

package/model-doctor.mjs

@@ -12,7 +12,7 @@ import { open, mkdir, readdir, writeFile } from "node:fs/promises";
 import { arch, homedir, platform, totalmem } from "node:os";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { ensureSupportedPython, isBuildToolsMissing } from "./platform-tools.mjs";
+import { ensureSupportedPython, isBuildToolsMissing, buildFailureMessage } from "./platform-tools.mjs";
 
 // Minimum RAM to run the default 14B-4bit chat model comfortably on Apple Silicon.
 const MIN_CHAT_RAM_GB = 16;
@@ -207,12 +207,7 @@ async function pipInstall(pkgs, log) {
   log(`  installing ${pkgs.join(" ")} … (pip, this can take a minute)`);
   let r = await runPip(python3Bin(), pkgs);
   if (r.code === 0) return;
-  if (isBuildToolsMissing(r.err)) {
-    throw new Error(
-      "pip had to compile a package and this machine has no C++ compiler. Use Python 3.13 or 3.12 (64-bit), which " +
-      "has prebuilt packages: " + pythonInstallHint() + ". Then run gu doctor again."
-    );
-  }
+  if (isBuildToolsMissing(r.err)) throw new Error(buildFailureMessage(r.err));
   const noPip = isPipMissing(r.err);
   if (!noPip && !isExternallyManaged(r.err)) {
     throw new Error(`pip install ${pkgs.join(" ")} exited ${r.code}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.868",
+  "version": "1.0.870",
   "description": "Gu CLI — the gu terminal plus the local worker that runs agent / OCR / PDF / embedding jobs on your Mac (Ollama / MLX / OpenAI-compatible).",
   "type": "module",
   "license": "MIT",
@@ -122,6 +122,7 @@
     "model-doctor.mjs",
     "coding-key-prompt.mjs",
     "model-fallback.mjs",
+    "quick-models.mjs",
     "terminal-title.mjs",
     "gu-relaunch.mjs",
     "server-keys.mjs",

package/platform-tools.mjs

@@ -314,9 +314,37 @@ export async function ensureSupportedPython({
   };
 }
 
-/** pip's "I had to compile and there is no compiler" failure. */
+/**
+ * pip's "I had to compile and could not" failure. Newer pip words it "error: failed-wheel-build-for-install /
+ * Failed to build installable wheels for some pyproject.toml based projects" (reported on a Windows 11
+ * customer installing smolagents + openai, #232), older pip "Failed building wheel for X".
+ */
 export function isBuildToolsMissing(output) {
-  return /Microsoft Visual C\+\+ 14\.0 or greater is required|Failed building wheel for|error: command '(?:gcc|cl\.exe)' failed/i.test(String(output ?? ""));
+  return /Microsoft Visual C\+\+ 14\.0 or greater is required|Failed building wheel for|failed-wheel-build-for-install|Failed to build installable wheels|error: command '(?:gcc|cl\.exe)' failed|could not find (?:`?cargo`?|rustc)|metadata-generation-failed/i.test(String(output ?? ""));
+}
+
+/** The packages pip could not build: ["pydantic-core", "jiter"], from either pip wording. */
+export function failedBuildPackages(output) {
+  const text = String(output ?? "");
+  const names = new Set();
+  for (const m of text.matchAll(/Failed building wheel for ([A-Za-z0-9_.-]+)/g)) names.add(m[1]);
+  // New pip: "╰─> pydantic-core" (or "-> pydantic-core") under the failed-wheel-build summary.
+  const at = text.search(/Failed to build installable wheels/i);
+  if (at >= 0) for (const m of text.slice(at).matchAll(/^\s*(?:╰─>|\+->|->)\s*([A-Za-z0-9_.-]+)\s*$/gm)) names.add(m[1]);
+  return [...names];
+}
+
+/** What to tell the user when pip could not build wheels: which package, and the fix that works. */
+export function buildFailureMessage(output, { platform = process.platform } = {}) {
+  const names = failedBuildPackages(output);
+  const what = names.length ? `pip could not build ${names.join(", ")}` : "pip had to compile a package and could not";
+  const rust = /rustc|cargo|maturin|pydantic[-_]core|jiter|rpds/i.test(String(output ?? "")) || names.some((n) => /pydantic[-_]core|jiter|rpds/i.test(n));
+  const how = platform === "win32" ? "winget install Python.Python.3.13" : "your package manager, e.g. python3.13";
+  return (
+    `${what}. That happens when this Python has no prebuilt package for it (too new, 32-bit, or ARM) and the machine ` +
+    `has no compiler${rust ? " (these packages need the Rust toolchain)" : ""}. Install 64-bit Python 3.13 (${how}), ` +
+    `open a new terminal, then run gu doctor again.`
+  );
 }
 
 /** How to SAY the resolved interpreter in a log line or error message. */

package/quick-models.mjs

@@ -0,0 +1,64 @@
+/**
+ * QUICK MODELS (#233) — two coding models to flip between with ← / → at the prompt.
+ *
+ * Pure helpers only (no I/O, no terminal): the picker, the key and the bar live in gu-repl.mjs and
+ * call these, so the rules below are testable. A quick model is the same (backend, model) PAIR
+ * /model offers — { id, model, kind, url } — stored whole, so a switch needs no network round trip
+ * to find out what "claude-opus" meant. At most TWO: the point is a flip, not a menu.
+ */
+
+export const QUICK_MAX = 2;
+
+/** At most QUICK_MAX distinct choices, each with an id; anything else in the saved list is dropped. */
+export function normalizeQuick(list) {
+  const out = [];
+  for (const c of Array.isArray(list) ? list : []) {
+    const id = typeof c?.id === "string" ? c.id.trim() : "";
+    if (!id || out.some((o) => o.id === id)) continue;
+    out.push({
+      id,
+      model: typeof c.model === "string" && c.model ? c.model : id,
+      kind: typeof c.kind === "string" ? c.kind : "",
+      url: typeof c.url === "string" ? c.url : "",
+    });
+    if (out.length === QUICK_MAX) break;
+  }
+  return out;
+}
+
+/** The ← / → flip needs exactly two. One quick model is a pin, not a flip. */
+export const quickReady = (quick) => normalizeQuick(quick).length === QUICK_MAX;
+
+/**
+ * Where ← / → goes. Active is one of the two → the OTHER one. Active is neither (the user picked
+ * something else with /model) → the first one, so a key press always lands somewhere defined.
+ * null when fewer than two are chosen.
+ */
+export function quickTarget(quick, activeId) {
+  const q = normalizeQuick(quick);
+  if (q.length < QUICK_MAX) return null;
+  const at = q.findIndex((c) => c.id === activeId);
+  return at < 0 ? q[0] : q[1 - at];
+}
+
+/** Does a model id match a quick choice? The session stores "" for the account default. */
+export const isQuickActive = (quick, activeId) => normalizeQuick(quick).some((c) => c.id === activeId);
+
+/** The dim hint beside the mode on the bar: only when the keys do something. */
+export const quickBarHint = (quick) => (quickReady(quick) ? "← → switch model" : "");
+
+/**
+ * The yellow warning row: quick models are chosen but the model in use is not one of them, so ← / →
+ * would not toggle what the user thinks it toggles. Plain text, cut to `width` with an ellipsis.
+ */
+export function quickWarning(quick, activeId, { width = 80, gutter = "   " } = {}) {
+  const q = normalizeQuick(quick);
+  if (q.length === 0 || isQuickActive(q, activeId)) return "";
+  const full = q.length === QUICK_MAX
+    ? `⚠ not on a quick model — ← → goes to ${q[0].model} · /quick-models`
+    : "⚠ not on your quick model · pick 2 with /quick-models to use ← →";
+  const short = "⚠ not on a quick model · /quick-models";
+  const room = Math.max(8, (width || 80) - 1 - gutter.length);
+  const pick = full.length <= room ? full : short;
+  return pick.length <= room ? pick : pick.slice(0, Math.max(1, room - 1)) + "…";
+}