@tiens.nguyen/gu-cli 1.0.866 → 1.0.868

package/gu-repl.mjs

@@ -2935,7 +2935,7 @@ const footerBuilt = () =>
     identity: identityLineText(),
     token: tokenLineText(),
     mode: modeLineText(),
-    // Task #34: "rag: embedder down → grep fallback" as a soft yellow note beside the mode, not an
+    // Task #34: "rag: using grep" as a soft yellow note beside the mode, not an
     // alarming red segment on the token row. yellow goes through paint(), so NO_COLOR turns it off.
     // Issue #120: an auto-compaction this turn outranks the rag note (same soft yellow slot).
     modeNote: compactLockNote() || compactBarNote(lastPromptBreakdown) || ragBarNote(lastPromptBreakdown),

package/model-doctor.mjs

@@ -12,6 +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";
 
 // Minimum RAM to run the default 14B-4bit chat model comfortably on Apple Silicon.
 const MIN_CHAT_RAM_GB = 16;
@@ -144,7 +145,8 @@ export function isPipMissing(output) {
 /** Run pip once. Resolves { code, err } — never rejects, so the caller owns the policy. */
 function runPip(python, pkgs, extraArgs = []) {
   return new Promise((resolve) => {
-    const child = spawn(python, ["-m", "pip", "install", "-U", ...extraArgs, ...pkgs], {
+    // --prefer-binary: take an older wheel over a newer source build (a compiler is not a given, #225).
+    const child = spawn(python, ["-m", "pip", "install", "-U", "--prefer-binary", ...extraArgs, ...pkgs], {
       // stderr is PIPED so the PEP 668 marker can be recognised, and echoed as it arrives so
       // the user still watches a real install rather than a frozen line.
       stdio: ["ignore", "inherit", "pipe"],
@@ -198,9 +200,19 @@ async function ensureVenv(log) {
  * venv cannot be built, --break-system-packages, which is announced rather than done quietly.
  */
 async function pipInstall(pkgs, log) {
+  // A Python newer than the wheels (3.15 -> PyYAML builds from source -> "Visual C++ 14.0 is required"): #225.
+  const sp = await ensureSupportedPython({ log });
+  if (!sp.ok) throw new Error(sp.message);
+  if (sp.switched) await pinPythonForDaemon({ 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."
+    );
+  }
   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.866",
+  "version": "1.0.868",
   "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",

package/platform-tools.mjs

@@ -233,6 +233,92 @@ export async function resolvePython() {
     : { cmd: "python3", args: [] };
 }
 
+/* ------------------------------------------- a Python new enough to lack wheels (#225) ---- */
+
+/**
+ * The newest Python that gu's packages (PyYAML via smolagents, pillow, ...) ship prebuilt wheels for.
+ * Above it pip BUILDS FROM SOURCE, which on Windows asks for Visual C++ 14 and ends in
+ * "Microsoft Visual C++ 14.0 or greater is required" (reported with Python 3.15). Raise it as wheels land.
+ */
+export const PYTHON_WHEELS_MAX = [3, 14];
+
+/** "3.15.0" / "3.15" -> [3, 15], or null when it is not a version. */
+export function parsePyVersion(out) {
+  const m = /^\s*(\d+)\.(\d+)/.exec(String(out ?? ""));
+  return m ? [Number(m[1]), Number(m[2])] : null;
+}
+
+/** Is this [major, minor] newer than the newest Python with wheels? */
+export function pythonTooNew(v, max = PYTHON_WHEELS_MAX) {
+  return Array.isArray(v) && (v[0] > max[0] || (v[0] === max[0] && v[1] > max[1]));
+}
+
+/** Older interpreters to fall back to, best first (3.13, 3.12 are the most widely wheeled). */
+export function altPythonCandidates(platform = process.platform) {
+  const minors = [13, 12, 14, 11, 10];
+  return platform === "win32"
+    ? minors.map((m) => ({ cmd: "py", args: [`-3.${m}`] }))
+    : minors.map((m) => ({ cmd: `python3.${m}`, args: [] }));
+}
+
+const EXE_PROBE = ["-c", "import sys; print(sys.executable)"];
+const VER_PROBE = ["-c", "import sys; print('%d.%d' % sys.version_info[:2])"];
+
+/**
+ * The first older interpreter that runs, as { cmd, args, exe } (exe = its real path), or null.
+ * `probe(cmd, args)` resolves stdout or null; injectable for the tests.
+ */
+export async function findSupportedPython({ platform = process.platform, probe = (c, a) => run(c, a, { timeout: 8000 }) } = {}) {
+  for (const c of altPythonCandidates(platform)) {
+    const exe = String((await probe(c.cmd, [...c.args, ...EXE_PROBE])) ?? "").trim();
+    if (exe && !/\n/.test(exe)) return { ...c, exe };
+  }
+  return null;
+}
+
+/**
+ * Make sure the Python gu will install packages into is one that has wheels.
+ * - GONEXT_PROBE_PYTHON set: the user chose; leave it.
+ * - default Python fine: nothing to do.
+ * - default too new: switch to an older one (sets GONEXT_PROBE_PYTHON in `env`, so every spawn in
+ *   this process follows) or say plainly what to install. Never starts a build that cannot succeed.
+ * Resolves { ok, switched?, from?, message? }.
+ */
+export async function ensureSupportedPython({
+  platform = process.platform,
+  env = process.env,
+  probe = (c, a) => run(c, a, { timeout: 8000 }),
+  log = () => {},
+} = {}) {
+  if ((env.GONEXT_PROBE_PYTHON ?? env.GONEXT_MLX_LM_PYTHON ?? "").trim()) return { ok: true };
+  let version = null;
+  for (const c of pythonCandidates(platform)) {
+    version = parsePyVersion(await probe(c.cmd, [...c.args, ...VER_PROBE]));
+    if (version) break;
+  }
+  if (!version || !pythonTooNew(version)) return { ok: true };
+  const from = version.join(".");
+  const alt = await findSupportedPython({ platform, probe });
+  if (alt) {
+    env.GONEXT_PROBE_PYTHON = alt.exe;
+    log(`  Python ${from} is too new for gu's packages (no prebuilt wheels yet) - using ${alt.exe} instead.`);
+    return { ok: true, switched: alt.exe, from };
+  }
+  const how = platform === "win32" ? "winget install Python.Python.3.13, or python.org" : "your package manager, or python.org";
+  return {
+    ok: false,
+    from,
+    message:
+      `Python ${from} is too new: gu's packages (PyYAML and others) have no prebuilt ${platform === "win32" ? "Windows " : ""}` +
+      `wheels for it yet, so pip would try to compile them. Install Python 3.13 (${how}), open a new terminal, then run gu doctor again.`,
+  };
+}
+
+/** pip's "I had to compile and there is no compiler" failure. */
+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 ?? ""));
+}
+
 /** How to SAY the resolved interpreter in a log line or error message. */
 export const pythonLabel = (py) => [py.cmd, ...py.args].join(" ");
 

package/terminal-layout.mjs

@@ -148,7 +148,7 @@ export function ragSegmentLabel(b) {
   switch (b.ragState) {
     // Task #34: no "✗" — search still works through grep, so this is a notice, not an error.
     case "unreachable":
-      return "rag: embedder down → grep fallback";
+      return "rag: using grep";
     case "no-index":
       return "rag — not indexed";
     case "unavailable":