offgrid-ai 0.10.2 → 0.11.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "offgrid-ai",
-  "version": "0.10.2",
+  "version": "0.11.1",
   "description": "Privacy-first CLI for running local LLMs — discover, configure, run, benchmark",
   "author": "Eeshan Srivastava (https://eeshans.com)",
   "type": "module",

package/src/backends.mjs

@@ -1,7 +1,7 @@
 import { findLlamaServer } from "./config.mjs";
 import { scanGgufModels } from "./scan.mjs";
 import { parseModelName } from "./model-name.mjs";
-import { scanMlxModels, scanOmlxModelSizes, lookupOmlxModelSize } from "./mlx-discovery.mjs";
+import { scanMlxModels, scanOmlxModelSizes, lookupOmlxModelInfo } from "./mlx-discovery.mjs";
 import { DEFAULT_PORT as MLX_VLM_PORT } from "./mlx-flags.mjs";
 
 // ── Backend definitions ────────────────────────────────────────────────────
@@ -96,20 +96,25 @@ async function scanOmlxModels() {
   const body = await response.json();
   if (!Array.isArray(body?.data)) return [];
 
-  // The oMLX API doesn't return model sizes — look them up from disk.
-  const sizeMap = await scanOmlxModelSizes();
+  // The oMLX API doesn't return model sizes or publishers — look them up from disk.
+  const infoMap = await scanOmlxModelSizes();
 
   return body.data
     .filter((model) => isChatOmlxModel(model))
     .map((model) => {
-      const sizeFromDisk = lookupOmlxModelSize(model.id, sizeMap);
+      const info = lookupOmlxModelInfo(model.id, infoMap);
+      // If the API ID doesn't already include a publisher (no / or --),
+      // prepend the publisher found on disk.
+      const hasPublisher = model.id.includes("/") || model.id.includes("--");
+      const fullName = (!hasPublisher && info?.publisher) ? `${info.publisher}/${model.id}` : model.id;
+      const parsed = parseModelName(fullName, "omlx");
       return {
         id: model.id,
-        label: parseModelName(model.id, "omlx").display,
+        label: parsed.display,
         aliasSuggestion: model.id,
-        sizeBytes: sizeFromDisk ?? (model.size ?? 0),
+        sizeBytes: info?.sizeBytes ?? (model.size ?? 0),
         contextLength: model.max_model_len ?? null,
-        quant: null,
+        quant: parsed.quant,
         family: null,
         backend: "omlx",
         source: "omlx",

package/src/mlx-discovery.mjs

@@ -16,6 +16,7 @@ import { join, basename } from "node:path";
 import { homedir } from "node:os";
 import { getModelScanDirs } from "./config.mjs";
 import { inferSourceLabel, MIN_MODEL_SIZE_BYTES, EMBEDDING_MODEL_TYPES } from "./discovery-shared.mjs";
+import { parseModelName } from "./model-name.mjs";
 
 // ── Folder → backend mapping ──────────────────────────────────────────────
 // The oMLX folder is oMLX-exclusive: models there are served by the oMLX
@@ -81,7 +82,8 @@ async function scanDirRecursiveForMlx(rootDir, sourceLabel, maxDepth = 3) {
       if (sizeBytes < MIN_MODEL_SIZE_BYTES) return;
       if (await isEmbeddingMlxModel(join(dir, "config.json"))) return;
       const caps = await detectMlxCapabilities(dir);
-      models.push(makeMlxModel(dir, basename(dir), sizeBytes, sourceLabel, rootDir, caps.contextLength));
+      const { display, quant } = parseModelName(basename(dir), sourceLabel);
+      models.push(makeMlxModel(dir, display, sizeBytes, sourceLabel, rootDir, caps.contextLength, quant));
       return;
     }
 
@@ -94,7 +96,12 @@ async function scanDirRecursiveForMlx(rootDir, sourceLabel, maxDepth = 3) {
           if (sizeBytes < MIN_MODEL_SIZE_BYTES) continue;
           if (await isEmbeddingMlxModel(join(fullPath, "config.json"))) continue;
           const caps = await detectMlxCapabilities(fullPath);
-          models.push(makeMlxModel(fullPath, entry.name, sizeBytes, sourceLabel, rootDir, caps.contextLength));
+          // Extract publisher from parent dir (LM Studio: publisher/model-dir)
+          const relParts = fullPath.slice(rootDir.length + 1).split("/");
+          const publisher = (sourceLabel === "lmstudio" && relParts.length >= 2) ? relParts[0] : null;
+          const rawLabel = publisher ? `${publisher}/${entry.name}` : entry.name;
+          const { display, quant } = parseModelName(rawLabel, sourceLabel);
+          models.push(makeMlxModel(fullPath, display, sizeBytes, sourceLabel, rootDir, caps.contextLength, quant));
         } else {
           await walk(fullPath, depth + 1);
         }
@@ -151,13 +158,16 @@ async function scanHfHubForMlx(dir, sourceLabel) {
       const sizeBytes = await getMlxDirSizeBytes(snapshotPath);
       if (sizeBytes < MIN_MODEL_SIZE_BYTES) continue;
       if (await isEmbeddingMlxModel(join(snapshotPath, "config.json"))) continue;
+      const caps = await detectMlxCapabilities(snapshotPath);
+      const { display, quant } = parseModelName(label, sourceLabel);
       models.push({
         id: `${sourceLabel}:${entry.name}`,
-        label,
+        label: display,
         path: snapshotPath,
         filePath: snapshotPath,
         sizeBytes,
-        contextLength: (await detectMlxCapabilities(snapshotPath)).contextLength,
+        contextLength: caps.contextLength,
+        quant,
         backend: "mlx-vlm",
         format: "mlx",
         source: sourceLabel,
@@ -188,7 +198,7 @@ async function isEmbeddingMlxModel(configPath) {
 
 // ── MLX model entry builder ───────────────────────────────────────────────
 
-function makeMlxModel(dir, label, sizeBytes, sourceLabel, rootDir, contextLength = null) {
+function makeMlxModel(dir, label, sizeBytes, sourceLabel, rootDir, contextLength = null, quant = null) {
   return {
     id: `${sourceLabel}:${dir.replace(rootDir + "/", "")}`,
     label,
@@ -196,6 +206,7 @@ function makeMlxModel(dir, label, sizeBytes, sourceLabel, rootDir, contextLength
     filePath: dir,
     sizeBytes,
     contextLength,
+    quant,
     backend: "mlx-vlm",
     format: "mlx",
     source: sourceLabel,
@@ -297,14 +308,14 @@ export function defaultMlxContextLength(trainedCtx, ramGb) {
 
 /**
  * Scan the oMLX models directory (~/.omlx/models/) for MLX model directories
- * and return a Map of basename → sizeBytes.  The oMLX API doesn't return model
- * sizes, so we compute them from the safetensors files on disk.
+ * and return a Map of basename → { sizeBytes, publisher }.  The oMLX API
+ * doesn't return model sizes or publishers, so we compute them from disk.
  */
 export async function scanOmlxModelSizes() {
   if (!existsSync(OMLX_MODELS_DIR)) return new Map();
-  const sizeByBasename = new Map();
+  const infoByBasename = new Map();
 
-  async function walk(dir) {
+  async function walk(dir, publisher) {
     let entries;
     try {
       entries = await readdir(dir, { withFileTypes: true });
@@ -316,26 +327,27 @@ export async function scanOmlxModelSizes() {
       const fullPath = join(dir, entry.name);
       if (await isMlxModelDir(fullPath)) {
         const sizeBytes = await getMlxDirSizeBytes(fullPath);
-        if (sizeBytes > 0) sizeByBasename.set(entry.name, sizeBytes);
+        if (sizeBytes > 0) infoByBasename.set(entry.name, { sizeBytes, publisher });
       } else {
-        await walk(fullPath);
+        // First-level directories under ~/.omlx/models/ are publishers
+        await walk(fullPath, publisher ?? entry.name);
       }
     }
   }
 
-  await walk(OMLX_MODELS_DIR);
-  return sizeByBasename;
+  await walk(OMLX_MODELS_DIR, null);
+  return infoByBasename;
 }
 
 /**
- * Look up a model's size by its oMLX API id.  Tries exact match, then the
+ * Look up a model's info by its oMLX API id.  Tries exact match, then the
  * segment after `--` (oMLX org--name format), then after `/` (HF format).
  */
-export function lookupOmlxModelSize(modelId, sizeMap) {
-  if (sizeMap.has(modelId)) return sizeMap.get(modelId);
+export function lookupOmlxModelInfo(modelId, infoMap) {
+  if (infoMap.has(modelId)) return infoMap.get(modelId);
   const dashIdx = modelId.indexOf("--");
-  if (dashIdx >= 0 && sizeMap.has(modelId.slice(dashIdx + 2))) return sizeMap.get(modelId.slice(dashIdx + 2));
+  if (dashIdx >= 0 && infoMap.has(modelId.slice(dashIdx + 2))) return infoMap.get(modelId.slice(dashIdx + 2));
   const slashIdx = modelId.indexOf("/");
-  if (slashIdx >= 0 && sizeMap.has(modelId.slice(slashIdx + 1))) return sizeMap.get(modelId.slice(slashIdx + 1));
+  if (slashIdx >= 0 && infoMap.has(modelId.slice(slashIdx + 1))) return infoMap.get(modelId.slice(slashIdx + 1));
   return null;
 }

package/src/model-catalog.mjs

@@ -72,6 +72,27 @@ export function buildCatalogItems(normalized) {
   const profileItems = profiles.map((profile) => {
     const item = { type: "profile", profile, label: profile.label, fileMissing: isProfileFileMissing(profile) };
 
+    // Resolve label + quant from scan data (re-parse for consistency)
+    let quant = profile.capabilities?.quant ?? null;
+    if (profile.modelPath) {
+      const scanModel = scanByPath.get(profile.modelPath);
+      if (scanModel) {
+        item.label = scanModel.label;  // re-parsed label (publisher/model-name)
+        if (scanModel.quant) quant = scanModel.quant;
+      }
+    }
+    if (!quant) {
+      const backend = backendFor(profile.backend);
+      if (backend.type === "managed-server" && profile.omlxModel) {
+        const managedModel = managedByKey.get(`${profile.backend}:${profile.omlxModel}`);
+        if (managedModel) {
+          item.label = managedModel.label;
+          if (managedModel.quant) quant = managedModel.quant;
+        }
+      }
+    }
+    item.quant = quant;
+
     // Resolve size: profile.modelSizeBytes → scan lookup → managed lookup
     let sizeBytes = profile.modelSizeBytes || 0;
     if (!sizeBytes && profile.modelPath) {
@@ -115,6 +136,7 @@ export function buildCatalogItems(normalized) {
       drafter: matchDrafter(model.path, drafters),
       sizeBytes: model.sizeBytes || null,
       contextLength: model.contextLength ?? null,
+      quant: model.quant ?? null,
     })),
     ...managedItems.map(({ model, backendId }) => ({
       type: "managed",
@@ -123,6 +145,7 @@ export function buildCatalogItems(normalized) {
       label: model.label,
       sizeBytes: model.sizeBytes || null,
       contextLength: model.contextLength ?? null,
+      quant: model.quant ?? null,
     })),
   ];
 }

package/src/model-name.mjs

@@ -54,6 +54,7 @@ const QUANT_PATTERNS = [
   /[-_]Q\d_[01]/i,
   /[-_]F(?:16|32)/i,
   /[-_]BF16/i,
+  /[-_]\d+bit\b/i,
 ];
 
 // ── Tag tokens extracted from the name ──────────────────────────────────
@@ -77,13 +78,20 @@ const TAG_TOKENS = [
 export function parseModelName(rawId, source) {
   const id = rawId; // never modify the raw id
 
-  // 1. Extract publisher (anything before the first /)
+  // 1. Extract publisher (anything before the first /, or -- for oMLX)
   let publisher = null;
   let name = rawId;
   const slashIdx = rawId.indexOf("/");
   if (slashIdx !== -1) {
     publisher = rawId.slice(0, slashIdx);
     name = rawId.slice(slashIdx + 1);
+  } else if (source === "omlx") {
+    // oMLX uses org--name format
+    const dashIdx = rawId.indexOf("--");
+    if (dashIdx !== -1) {
+      publisher = rawId.slice(0, dashIdx);
+      name = rawId.slice(dashIdx + 2);
+    }
   }
 
   // 2. Extract quant (GGUF quantization suffix)
@@ -125,7 +133,7 @@ export function parseModelName(rawId, source) {
   const params = extractParams(model);
 
   // 7. Build display string
-  const display = buildDisplay(publisher, model, tags, quant);
+  const display = buildDisplay(publisher, model, tags);
 
   // 8. Build sort key (lowercase, no publisher, for alphabetical ordering)
   const sort = model.toLowerCase().replace(/[-_]/g, " ");
@@ -135,20 +143,12 @@ export function parseModelName(rawId, source) {
 
 // ── Display builder ────────────────────────────────────────────────────
 
-function buildDisplay(publisher, model, tags, quant) {
-  const parts = [];
-  if (publisher) {
-    parts.push(publisher);
-  }
+function buildDisplay(publisher, model, tags) {
   let modelPart = model;
   if (tags.length > 0) {
     modelPart += ` (${tags.join(", ")})`;
   }
-  parts.push(modelPart);
-  if (quant) {
-    parts.push(quant);
-  }
-  return parts.join(" › ");
+  return publisher ? `${publisher}/${modelPart}` : modelPart;
 }
 
 // ── Params extraction ──────────────────────────────────────────────────
@@ -195,6 +195,9 @@ function titleCaseModel(name) {
   // Title-case standalone aXb patterns (A3B, A12B — active parameters)
   result = result.replace(/\ba(\d+)\s*b\b/gi, (_, num) => `A${num}B`);
 
+  // Title-case eXb patterns (E2B, E12B — effective parameters)
+  result = result.replace(/\be(\d+)\s*b\b/gi, (_, num) => `E${num}B`);
+
   // Clean up extra spaces
   result = result.replace(/\s{2,}/g, " ").trim();
 

package/src/model-presenters.mjs

@@ -14,6 +14,7 @@ const OPTION_SEPARATOR = pc.dim("  │  ");
 const OPTION_STATUS_WIDTH = 12;
 const OPTION_BACKEND_WIDTH = 14;
 const OPTION_SOURCE_WIDTH = 14;
+const OPTION_QUANT_WIDTH = 10;
 const OPTION_CTX_WIDTH = 5;
 
 const { stripVTControlCharacters } = await import("node:util");
@@ -100,6 +101,11 @@ function discoverySourceForItem(item) {
   return item.model?.source ?? null;
 }
 
+function optionQuantLabel(item) {
+  if (item.quant) return optionPad(item.quant, null, OPTION_QUANT_WIDTH);
+  return optionPad("—", null, OPTION_QUANT_WIDTH);
+}
+
 function optionCtxLabel(item) {
   // Context window is a configured value — only profiles (READY/RUNNING)
   // have one. SETUP items (new/managed) show "—".
@@ -123,8 +129,8 @@ export function modelNameWidth(items) {
   return Math.max(20, maxName + 2);
 }
 
-function optionLabel({ status, backend, source, name, ctx, size, nameWidth }) {
-  return [status, backend, source, pc.bold(optionPad(name, null, nameWidth)), ctx, pc.dim(size)].join(OPTION_SEPARATOR);
+function optionLabel({ status, backend, source, name, quant, ctx, size, nameWidth }) {
+  return [status, backend, source, pc.bold(optionPad(name, null, nameWidth)), quant, ctx, pc.dim(size)].join(OPTION_SEPARATOR);
 }
 
 export function modelSelectOption(item, { runningProfilesNow, modelMissingIds, nameWidth }) {
@@ -145,8 +151,9 @@ export function modelSelectOption(item, { runningProfilesNow, modelMissingIds, n
         status: optionStatusTag(status),
         backend: optionBackendTag(backendId),
         source: optionSourceTag(sourceId),
-        name: item.profile.label,
+        name: item.label,
         nameWidth,
+        quant: optionQuantLabel(item),
         ctx: optionCtxLabel(item),
         size: optionSizeLabel(item),
       }),
@@ -160,8 +167,9 @@ export function modelSelectOption(item, { runningProfilesNow, modelMissingIds, n
         status: optionStatusTag("setup"),
         backend: optionBackendTag(backendId),
         source: optionSourceTag(sourceId),
-        name: item.model.label,
+        name: item.label,
         nameWidth,
+        quant: optionQuantLabel(item),
         ctx: optionCtxLabel(item),
         size: optionSizeLabel(item),
       }),
@@ -173,8 +181,9 @@ export function modelSelectOption(item, { runningProfilesNow, modelMissingIds, n
       status: optionStatusTag("setup"),
       backend: optionBackendTag(backendId),
       source: optionSourceTag(sourceId),
-      name: item.model.label,
+      name: item.label,
       nameWidth,
+      quant: optionQuantLabel(item),
       ctx: optionCtxLabel(item),
       size: optionSizeLabel(item),
     }),

package/src/scan.mjs

@@ -52,8 +52,6 @@ async function scanOneDir(root, sourceLabel = "local-gguf") {
     const name = basename(path).replace(/\.gguf$/i, "");
     const sizeBytes = statSync(path).size;
     if (sizeBytes < MIN_MODEL_SIZE_BYTES) continue;
-    const parsed = parseModelName(name, "local-gguf");
-
     // Read GGUF metadata to detect drafter architecture and embeddings
     const meta = safeReadGgufMetadata(path);
     const architecture = typeof meta["general.architecture"] === "string" ? meta["general.architecture"] : null;
@@ -61,6 +59,12 @@ async function scanOneDir(root, sourceLabel = "local-gguf") {
       ? meta[`${architecture}.context_length`]
       : null;
 
+    // Extract publisher from GGUF metadata (repo_url or quantized_by),
+    // falling back to directory structure (LM Studio: publisher/model-dir/file).
+    const publisher = publisherFromGgufMeta(meta) ?? publisherFromPath(path, root, sourceLabel);
+
+    const parsed = parseModelName(publisher ? `${publisher}/${name}` : name, sourceLabel);
+
     if (isEmbeddingArchitecture(architecture, name)) continue;
 
     if (architecture === "gemma4-assistant" || architecture === "gemma4_assistant") {
@@ -189,4 +193,37 @@ function safeReadGgufMetadata(path) {
   } catch {
     return {};
   }
+}
+
+// ── Publisher extraction ─────────────────────────────────────────────────
+
+/** Extract publisher from GGUF metadata (repo_url or quantized_by). */
+function publisherFromGgufMeta(meta) {
+  const repoUrl = meta["general.repo_url"];
+  if (typeof repoUrl === "string") {
+    const match = repoUrl.match(/huggingface\.co\/([^/?#]+)/i);
+    if (match) return match[1];
+  }
+  const quantizedBy = meta["general.quantized_by"];
+  if (typeof quantizedBy === "string" && quantizedBy.trim()) {
+    return quantizedBy.trim().toLowerCase();
+  }
+  return null;
+}
+
+/** Extract publisher from directory structure relative to the scan root. */
+function publisherFromPath(filePath, scanRoot, sourceLabel) {
+  const rel = filePath.slice(scanRoot.length + 1).replace(/\\/g, "/");
+  const parts = rel.split("/");
+  if (parts.length === 0) return null;
+  // HF hub: models--org--name/snapshots/hash/file
+  if (parts[0]?.startsWith("models--")) {
+    const after = parts[0].slice("models--".length);
+    const dashIdx = after.indexOf("--");
+    if (dashIdx > 0) return after.slice(0, dashIdx);
+    return null;
+  }
+  // LM Studio: publisher/model-dir/file.gguf (3+ parts)
+  if (sourceLabel === "lmstudio" && parts.length >= 3) return parts[0];
+  return null;
 }