offgrid-ai 0.8.15 → 0.9.2

package/src/cli.mjs

@@ -10,7 +10,7 @@ import { uninstallCommand } from "./commands/uninstall.mjs";
 
 async function offerUpdate(argv) {
   const invocation = detectInvocation();
-  const update = await checkForUpdate({ force: false });
+  const update = await checkForUpdate();
   if (!update) return false;
 
   const plan = updateCommand(invocation, argv);
@@ -56,7 +56,7 @@ async function printVersion() {
   const version = currentPackageVersion();
   console.log(`offgrid-ai v${version}`);
   const invocation = detectInvocation();
-  const update = await checkForUpdate({ force: false });
+  const update = await checkForUpdate();
   if (update) {
     const plan = updateCommand(invocation, ["version"]);
     console.log(pc.yellow(`Update available: v${update.latest}. Run: ${plan.display}`));

package/src/commands/main.mjs

@@ -27,8 +27,8 @@ export async function mainFlow() {
   const { models: ggufModels, drafters } = await scanGgufModels();
   const managedModels = await scanManagedModels();
   const profiles = await loadProfiles();
-  const hasAnyBackend = llamaBinary || managedModels.some((item) => item.models.length > 0);
-  const hasAnyModels = ggufModels.length > 0 || managedModels.some((item) => item.models.length > 0);
+  const hasAnyBackend = llamaBinary || managedModels.some((item) => item.status === "ok" && item.models.length > 0);
+  const hasAnyModels = ggufModels.length > 0 || managedModels.some((item) => item.status === "ok" && item.models.length > 0);
 
   const piInstalled = await hasPi();
   const needsLlama = ggufModels.length > 0 || profiles.some((profile) => backendFor(profile.backend).type === "local-server");

package/src/commands/onboard.mjs

@@ -90,8 +90,12 @@ function printFoundModels(ggufModels, managedModels, llamaBinary) {
     console.log(pc.green(`✓ Found ${ggufModels.length} GGUF model${ggufModels.length === 1 ? "" : "s"}`));
     if (!llamaBinary) console.log(pc.yellow("Install the managed llama.cpp runtime to run these GGUF models."));
   }
-  for (const { backendId, models } of managedModels) {
-    if (models.length > 0) console.log(pc.green(`✓ ${BACKENDS[backendId].label}: ${models.length} model${models.length === 1 ? "" : "s"}`));
+  for (const { backendId, models, status, reason } of managedModels) {
+    if (status === "unavailable") {
+      console.log(pc.yellow(`${BACKENDS[backendId].label}: unavailable${reason ? ` — ${reason}` : ""}`));
+    } else if (models.length > 0) {
+      console.log(pc.green(`✓ ${BACKENDS[backendId].label}: ${models.length} model${models.length === 1 ? "" : "s"}`));
+    }
   }
 }
 

package/src/config.mjs

@@ -46,8 +46,13 @@ export async function loadConfig() {
   try {
     const raw = await readFile(CONFIG_PATH, "utf8");
     return { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
-  } catch {
-    return { ...DEFAULT_CONFIG };
+  } catch (error) {
+    if (error?.code === "ENOENT") return { ...DEFAULT_CONFIG };
+    throw new Error(
+      `Failed to read config at ${CONFIG_PATH}: ${error.message}. ` +
+      `Fix or remove the file, then try again.`,
+      { cause: error }
+    );
   }
 }
 
@@ -99,6 +104,7 @@ export async function findLlamaServer() {
     if (existsSync(candidate)) return candidate;
   } catch { /* Homebrew not installed or llama.cpp not brewed */ }
 
+  // No llama-server found — caller must present actionable error or onboarding.
   return null;
 }
 

package/src/harness-pi.mjs

@@ -70,7 +70,7 @@ export async function hasPi() {
 // ── Internals ──────────────────────────────────────────────────────────────
 
 async function activeProviderProfiles(currentProfile) {
-  const allProfiles = await loadProfiles().catch(() => []);
+  const allProfiles = await loadProfiles();
   const byAlias = new Map();
   for (const item of [...allProfiles, currentProfile]) {
     if (item.providerId !== currentProfile.providerId) continue;

package/src/managed.mjs

@@ -10,9 +10,9 @@ export async function scanManagedModels() {
     const backend = BACKENDS[backendId];
     try {
       const models = await backend.scanModels();
-      results.push({ backendId, models });
-    } catch {
-      // Managed backends are optional and may not be running.
+      results.push({ backendId, models, status: "ok" });
+    } catch (error) {
+      results.push({ backendId, models: [], status: "unavailable", reason: error?.message ?? String(error) });
     }
   }
   return results;

package/src/model-catalog.mjs

@@ -18,7 +18,8 @@ export function normalizeCatalog(catalog) {
   const profiledPaths = new Set(profiles.map((profile) => profile.modelPath).filter(Boolean));
   const newModels = ggufModels.filter((model) => !profiledPaths.has(model.path));
   const managedItems = [];
-  for (const { backendId, models } of managedModels) {
+  for (const { backendId, models, status } of managedModels) {
+    if (status === "unavailable") continue;
     const profiledAliases = new Set(
       profiles
         .filter((profile) => profile.backend === backendId)

package/src/model-name.mjs

@@ -0,0 +1,220 @@
+// ── Single path for parsing and formatting model names ─────────────────────
+//
+// Every model display name in offgrid-ai goes through parseModelName().
+// No other function should format, title-case, or dissect a model name.
+//
+// The returned `id` is always the raw identifier (untouched) and is used for
+// API calls, profile IDs, Pi config matching, and benchmark directory slugs.
+// The returned `display` is the human-readable string shown in pickers, details,
+// and benchmark metadata.
+
+// ── Known model families ────────────────────────────────────────────────
+//
+// Mapped to their title-case form. Matched as prefix tokens so "qwen"
+// matches "qwen3", "qwen2.5", etc.
+
+const FAMILY_TITLE_CASE = {
+  "deepseek-r": "DeepSeek-R",
+  "deepseek": "DeepSeek",
+  "starcoder2": "StarCoder2",
+  "starcoder": "StarCoder",
+  "command-r": "Command-R",
+  "command": "Command",
+  "codestral": "Codestral",
+  "mistral": "Mistral",
+  "mixtral": "Mixtral",
+  "mathstral": "Mathstral",
+  "pixtral": "Pixtral",
+  "gemma": "Gemma",
+  "qwen": "Qwen",
+  "llama": "Llama",
+  "phi": "Phi",
+  "yi": "Yi",
+  "zephyr": "Zephyr",
+  "internlm": "InternLM",
+  "cohere": "Cohere",
+  "falcon": "Falcon",
+  "baichuan": "Baichuan",
+  "mamba": "Mamba",
+  "solar": "Solar",
+  "granite": "Granite",
+  "dbrx": "DBRX",
+  "stablelm": "StableLM",
+};
+
+// Sort families by length descending so longer families match first
+const SORTED_FAMILIES = Object.keys(FAMILY_TITLE_CASE).sort((a, b) => b.length - a.length);
+
+// ── Quant patterns (order matters — longer/more-specific first) ────────
+
+const QUANT_PATTERNS = [
+  /[-_]UD-[A-Z0-9_]+/i,
+  /[-_]IQ[0-9_]+(?:_[A-Z]+)?/i,
+  /[-_]Q\d_K_[A-Z]+/i,
+  /[-_]Q\d_[01]/i,
+  /[-_]F(?:16|32)/i,
+  /[-_]BF16/i,
+];
+
+// ── Tag tokens extracted from the name ──────────────────────────────────
+
+const TAG_TOKENS = [
+  "it", "instruct", "chat", "code", "base", "vision", "mtp",
+  "mmproj", "draft", "assistant",
+];
+
+// ── Main entry point ───────────────────────────────────────────────────
+
+/**
+ * Parse a raw model identifier into a structured display name.
+ *
+ * @param {string} rawId  The raw identifier: GGUF filename (no .gguf),
+ *                        Ollama model name, or oMLX model id.
+ * @param {"local-gguf"|"ollama"|"omlx"} source  Where this name came from.
+ * @returns {{ publisher: string|null, model: string, params: string|null,
+ *             quant: string|null, tags: string[], display: string,
+ *             sort: string, id: string }}
+ */
+export function parseModelName(rawId, source) {
+  const id = rawId; // never modify the raw id
+
+  // 1. Extract publisher (anything before the first /)
+  let publisher = null;
+  let name = rawId;
+  const slashIdx = rawId.indexOf("/");
+  if (slashIdx !== -1) {
+    publisher = rawId.slice(0, slashIdx);
+    name = rawId.slice(slashIdx + 1);
+  }
+
+  // 2. For Ollama, split on : to separate model from tag (e.g. "gemma3:4b")
+  //    The tag after : is a model size/variant identifier — not a GGUF quant.
+  let ollamaTag = null;
+  if (source === "ollama") {
+    const colonIdx = name.lastIndexOf(":");
+    if (colonIdx !== -1) {
+      ollamaTag = name.slice(colonIdx + 1);
+      name = name.slice(0, colonIdx);
+    }
+  }
+
+  // 3. Extract quant (GGUF quantization suffix)
+  let quant = null;
+  for (const pattern of QUANT_PATTERNS) {
+    const match = name.match(pattern);
+    if (match) {
+      quant = match[0].replace(/^[-_]/, "");
+      name = name.slice(0, match.index) + name.slice(match.index + match[0].length);
+      break;
+    }
+  }
+
+  // 4. Extract known tags as hyphen/underscore-delimited tokens
+  const tags = [];
+  for (const tag of TAG_TOKENS) {
+    const tagRegex = new RegExp(`(?:^|[-_])${tag}(?:$|[-_])`, "i");
+    if (tagRegex.test(name)) {
+      tags.push(tag);
+      // Remove the tag token from the name
+      name = name.replace(new RegExp(`(?:^|[-_])${tag}(?=[-_]|$)`, "i"), (m) => {
+        // Preserve the leading hyphen/underscore boundary
+        return m.startsWith("-") || m.startsWith("_") ? "" : "";
+      });
+    }
+  }
+  // Clean up leftover separators
+  name = name.replace(/[-_]{2,}/g, "-").replace(/^[-_]+|[-_]+$/g, "");
+
+  // 5. For Ollama, re-attach the tag as part of the model name
+  //    (Ollama tags like "4b" or "30b-a3b" are size variants, not quants)
+  if (ollamaTag) {
+    name = name + "-" + ollamaTag;
+  }
+
+  // 6. Title-case the remaining model name
+  let model = titleCaseModel(name);
+
+  // If nothing is left after parsing, fall back to the raw name
+  if (!model || model.trim() === "") {
+    model = rawId.includes("/") ? rawId : rawId.replace(/[-_]/g, " ");
+  }
+
+  // 7. Extract params (size like 30B, 12B) for sort/filter convenience
+  const params = extractParams(model);
+
+  // 8. Build display string
+  const display = buildDisplay(publisher, model, tags, quant);
+
+  // 9. Build sort key (lowercase, no publisher, for alphabetical ordering)
+  const sort = model.toLowerCase().replace(/[-_]/g, " ");
+
+  return { publisher, model, params, quant, tags, display, sort, id };
+}
+
+// ── Display builder ────────────────────────────────────────────────────
+
+function buildDisplay(publisher, model, tags, quant) {
+  const parts = [];
+  if (publisher) {
+    parts.push(publisher);
+  }
+  let modelPart = model;
+  if (tags.length > 0) {
+    modelPart += ` (${tags.join(", ")})`;
+  }
+  parts.push(modelPart);
+  if (quant) {
+    parts.push(quant);
+  }
+  return parts.join(" › ");
+}
+
+// ── Params extraction ──────────────────────────────────────────────────
+
+function extractParams(model) {
+  const match = model.match(/\b(\d+(?:\.\d+)?)\s*B\b/);
+  return match ? match[1] + "B" : null;
+}
+
+// ── Title-case model names ────────────────────────────────────────────
+
+function titleCaseModel(name) {
+  // Replace hyphens and underscores with spaces
+  let result = name.replace(/[-_]/g, " ");
+
+  // Title-case known families (prefix match so "qwen" matches "qwen3", etc.)
+  // Insert a space between the family name and a following digit/version.
+  for (const family of SORTED_FAMILIES) {
+    const pattern = new RegExp(`\\b${family}(?=[0-9])`, "gi");
+    result = result.replace(pattern, FAMILY_TITLE_CASE[family] + " ");
+    // Also match family at end of word (no digit following)
+    const patternEnd = new RegExp(`\\b${family}(?![a-z0-9])`, "gi");
+    result = result.replace(patternEnd, FAMILY_TITLE_CASE[family]);
+  }
+
+  // Title-case param sizes (30b → 30B, 12b → 12B, 0.5b → 0.5B)
+  result = result.replace(/\b(\d+(?:\.\d+)?)\s*[bB]\b/g, (_, num) => {
+    return num + "B";
+  });
+
+  // Title-case version numbers that follow a family name (Gemma 3, Qwen 2.5)
+  // Pattern: family name followed by a space then a bare digit sequence
+  // that's not a param size (not followed by B/b).
+  // We already have "Gemma 4", "Qwen 3" etc. from family + spacing.
+  // Just ensure the numbers look clean.
+
+  // Title-case "it" and "instruct" if they survived tag extraction
+  result = result.replace(/\bit\b/g, "IT");
+  result = result.replace(/\binstruct\b/gi, "Instruct");
+
+  // Title-case "r1", "r2" etc. (DeepSeek-R1, etc.)
+  result = result.replace(/\br(\d+)\b/gi, (_, num) => `R${num}`);
+
+  // Title-case standalone aXb patterns (A3B, A12B — active parameters)
+  result = result.replace(/\ba(\d+)\s*b\b/gi, (_, num) => `A${num}B`);
+
+  // Clean up extra spaces
+  result = result.replace(/\s{2,}/g, " ").trim();
+
+  return result;
+}

package/src/process.mjs

@@ -195,47 +195,55 @@ export async function waitForReady(profile, pid, rawLogPath) {
 // ── Internals ──────────────────────────────────────────────────────────────
 
 async function serverModelIds(baseUrl) {
-  const body = await fetchJson(`${baseUrl.replace(/\/$/, "")}/models`);
-  return (Array.isArray(body?.data) ? body.data : [])
+  const result = await fetchJson(`${baseUrl.replace(/\/+$/u, "")}/models`);
+  if (!result.ok) return [];
+  return (Array.isArray(result.data?.data) ? result.data.data : [])
     .map((model) => String(model?.id ?? "").trim())
     .filter(Boolean);
 }
 
 async function ollamaLoadedModelIds(profile) {
-  const body = await fetchJson(`${apiRootUrl(profile.baseUrl)}/api/ps`);
-  return (Array.isArray(body?.models) ? body.models : [])
+  const result = await fetchJson(`${apiRootUrl(profile.baseUrl)}/api/ps`);
+  if (!result.ok) return [];
+  return (Array.isArray(result.data?.models) ? result.data.models : [])
     .flatMap((model) => [model?.name, model?.model])
     .map((id) => String(id ?? "").trim())
     .filter(Boolean);
 }
 
 async function omlxLoadedModelIds(profile) {
-  const status = await fetchJson(`${profile.baseUrl.replace(/\/$/, "")}/models/status`);
-  const fromStatus = (Array.isArray(status?.models) ? status.models : [])
-    .filter((model) => model?.loaded === true)
-    .flatMap((model) => [model?.id, model?.name, model?.model, model?.alias])
-    .map((id) => String(id ?? "").trim())
-    .filter(Boolean);
-  if (Number(status?.loaded_count) === 0) return fromStatus;
-
-  const summary = await fetchJson(`${apiRootUrl(profile.baseUrl)}/api/status`);
-  const fromSummary = (Array.isArray(summary?.loaded_models) ? summary.loaded_models : [])
-    .map((id) => String(id ?? "").trim())
-    .filter(Boolean);
+  const statusResult = await fetchJson(`${profile.baseUrl.replace(/\/+$/u, "")}/models/status`);
+  const fromStatus = statusResult.ok
+    ? (Array.isArray(statusResult.data?.models) ? statusResult.data.models : [])
+        .filter((model) => model?.loaded === true)
+        .flatMap((model) => [model?.id, model?.name, model?.model, model?.alias])
+        .map((id) => String(id ?? "").trim())
+        .filter(Boolean)
+    : [];
+  if (!statusResult.ok || Number(statusResult.data?.loaded_count) === 0) return fromStatus;
+
+  const summaryResult = await fetchJson(`${apiRootUrl(profile.baseUrl)}/api/status`);
+  const fromSummary = summaryResult.ok
+    ? (Array.isArray(summaryResult.data?.loaded_models) ? summaryResult.data.loaded_models : [])
+        .map((id) => String(id ?? "").trim())
+        .filter(Boolean)
+    : [];
   return [...fromStatus, ...fromSummary];
 }
 
 async function fetchJson(url) {
   try {
     const response = await fetch(url, { signal: AbortSignal.timeout(1000) });
-    if (!response.ok) return null;
-    return await response.json();
-  } catch {
-    return null;
+    if (!response.ok) return { ok: false, reason: "http", status: response.status, data: null };
+    const data = await response.json();
+    return { ok: true, data };
+  } catch (error) {
+    if (error?.name === "AbortError" || error?.name === "TimeoutError") return { ok: false, reason: "timeout", data: null };
+    return { ok: false, reason: "network", data: null };
   }
 }
 
-function apiRootUrl(baseUrl) {
+export function apiRootUrl(baseUrl) {
   try {
     const url = new URL(baseUrl);
     url.pathname = url.pathname.replace(/\/v1\/?$/u, "") || "/";

package/src/runtime.mjs

@@ -33,6 +33,12 @@ export async function offerManagedLlamaRuntimeUpdate(prompt, { fetchImpl = globa
   return true;
 }
 
+/**
+ * Check for the latest llama.cpp release on GitHub.
+ * Returns null if the check fails (network error, timeout, etc.).
+ * Callers must treat null as "check failed, skip prompt" — do not
+ * treat null as "no update available."
+ */
 export async function latestLlamaRelease(fetchImpl = globalThis.fetch) {
   try {
     const response = await fetchImpl(RELEASE_API, { signal: AbortSignal.timeout(5000) });
@@ -47,6 +53,11 @@ export async function latestLlamaRelease(fetchImpl = globalThis.fetch) {
   }
 }
 
+/**
+ * Read the installed runtime version from disk.
+ * Returns null if not installed or if the version file is missing/corrupt.
+ * Callers must treat null as "runtime not installed" — not as a hidden default.
+ */
 export async function installedRuntime() {
   try {
     return JSON.parse(await readFile(VERSION_PATH, "utf8"));

package/src/scan.mjs

@@ -3,6 +3,7 @@ import { readdir } from "node:fs/promises";
 import { basename, dirname, join } from "node:path";
 import { getModelScanDirs } from "./config.mjs";
 import { readGgufMetadata } from "./gguf.mjs";
+import { parseModelName } from "./model-name.mjs";
 
 // ── Scan for GGUF models and MTP drafters ────────────────────────────────
 
@@ -48,6 +49,7 @@ async function scanOneDir(root) {
     const mmprojPath = mmprojs.find((candidate) => dirname(candidate) === dir) ?? null;
     const name = basename(path).replace(/\.gguf$/i, "");
     const sizeBytes = statSync(path).size;
+    const parsed = parseModelName(name, "local-gguf");
 
     // Read GGUF metadata to detect drafter architecture
     const meta = safeReadGgufMetadata(path);
@@ -57,9 +59,9 @@ async function scanOneDir(root) {
       // This is an MTP drafter model, not a main model
       drafters.push({
         path,
-        label: labelFromName(name),
-        aliasSuggestion: aliasFromName(name),
-        quant: quantFromName(name),
+        label: parsed.display,
+        aliasSuggestion: parsed.id,
+        quant: parsed.quant,
         sizeBytes,
         architecture,
         targetHint: drafterTargetHint(name),
@@ -70,9 +72,9 @@ async function scanOneDir(root) {
       models.push({
         path,
         mmprojPath,
-        label: labelFromName(name),
-        aliasSuggestion: aliasFromName(name),
-        quant: quantFromName(name),
+        label: parsed.display,
+        aliasSuggestion: parsed.id,
+        quant: parsed.quant,
         sizeBytes,
         backend: "llama-cpp",
         source: "local-gguf",
@@ -143,20 +145,7 @@ async function findFiles(root, predicate) {
   return result;
 }
 
-function labelFromName(name) {
-  return name
-    .replace(/-/g, " ")
-    .replace(/\bqwen/i, "Qwen")
-    .replace(/q4_k_m/i, "Q4_K_M");
-}
-
-function aliasFromName(name) {
-  return name.replace(/-Q4_K_M$/i, "-GGUF");
-}
-
-function quantFromName(name) {
-  return name.match(/(Q\d_K_[A-Z]+|Q\d_[01]|UD-[A-Z0-9_]+)/)?.[1];
-}
+// (labelFromName, aliasFromName, quantFromName removed — parseModelName in model-name.mjs is the single path)
 
 
 function safeReadGgufMetadata(path) {