offgrid-ai 0.10.0 → 0.10.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "offgrid-ai",
-  "version": "0.10.0",
+  "version": "0.10.2",
   "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 } from "./mlx-discovery.mjs";
+import { scanMlxModels, scanOmlxModelSizes, lookupOmlxModelSize } from "./mlx-discovery.mjs";
 import { DEFAULT_PORT as MLX_VLM_PORT } from "./mlx-flags.mjs";
 
 // ── Backend definitions ────────────────────────────────────────────────────
@@ -95,18 +95,26 @@ 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();
+
   return body.data
     .filter((model) => isChatOmlxModel(model))
-    .map((model) => ({
-      id: model.id,
-      label: parseModelName(model.id, "omlx").display,
-      aliasSuggestion: model.id,
-      sizeBytes: model.size ?? 0,
-      quant: null,
-      family: null,
-      backend: "omlx",
-      source: "omlx",
-    })).sort((a, b) => a.label.localeCompare(b.label));
+    .map((model) => {
+      const sizeFromDisk = lookupOmlxModelSize(model.id, sizeMap);
+      return {
+        id: model.id,
+        label: parseModelName(model.id, "omlx").display,
+        aliasSuggestion: model.id,
+        sizeBytes: sizeFromDisk ?? (model.size ?? 0),
+        contextLength: model.max_model_len ?? null,
+        quant: null,
+        family: null,
+        backend: "omlx",
+        source: "omlx",
+      };
+    }).sort((a, b) => a.label.localeCompare(b.label));
 }
 
 // ── Labels ──────────────────────────────────────────────────────────────

package/src/commands/main.mjs

@@ -1,6 +1,7 @@
 import { findLlamaServer, ensureDirs } from "../config.mjs";
 import { backendFor } from "../backends.mjs";
 import { scanGgufModels } from "../scan.mjs";
+import { scanMlxModels } from "../mlx-discovery.mjs";
 import { loadProfiles } from "../profiles.mjs";
 import { hasPi } from "../harness-pi.mjs";
 import { offerManagedLlamaRuntimeUpdate } from "../runtime.mjs";
@@ -26,9 +27,10 @@ export async function mainFlow() {
   const llamaBinary = await findLlamaServer();
   const { models: ggufModels, drafters } = await scanGgufModels();
   const managedModels = await scanManagedModels();
+  const mlxModels = await scanMlxModels();
   const profiles = await loadProfiles();
   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 hasAnyModels = ggufModels.length > 0 || mlxModels.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");
@@ -56,7 +58,7 @@ export async function mainFlow() {
   if (!process.stdin.isTTY) return await statusCommand();
 
   startInteractive("offgrid-ai");
-  return await modelCommandCenter({ profiles, ggufModels, managedModels, drafters });
+  return await modelCommandCenter({ profiles, ggufModels, managedModels, mlxModels, drafters });
 }
 
 async function printNoModelsHelp(llamaBinary) {

package/src/commands/models.mjs

@@ -74,7 +74,7 @@ export async function modelCommandCenter(initialCatalog) {
     const bucket = grouped.get(group);
     if (!bucket || bucket.length === 0) continue;
     for (const item of bucket) {
-      const opt = modelSelectOption(item, { runningProfilesNow, modelMissingIds, nameWidth, managedModels: catalog.managedModels });
+      const opt = modelSelectOption(item, { runningProfilesNow, modelMissingIds, nameWidth });
       choices.push({ value: opt.value, label: opt.label, hint: opt.hint });
     }
   }

package/src/mlx-discovery.mjs

@@ -80,7 +80,8 @@ async function scanDirRecursiveForMlx(rootDir, sourceLabel, maxDepth = 3) {
       const sizeBytes = await getMlxDirSizeBytes(dir);
       if (sizeBytes < MIN_MODEL_SIZE_BYTES) return;
       if (await isEmbeddingMlxModel(join(dir, "config.json"))) return;
-      models.push(makeMlxModel(dir, basename(dir), sizeBytes, sourceLabel, rootDir));
+      const caps = await detectMlxCapabilities(dir);
+      models.push(makeMlxModel(dir, basename(dir), sizeBytes, sourceLabel, rootDir, caps.contextLength));
       return;
     }
 
@@ -92,7 +93,8 @@ async function scanDirRecursiveForMlx(rootDir, sourceLabel, maxDepth = 3) {
           const sizeBytes = await getMlxDirSizeBytes(fullPath);
           if (sizeBytes < MIN_MODEL_SIZE_BYTES) continue;
           if (await isEmbeddingMlxModel(join(fullPath, "config.json"))) continue;
-          models.push(makeMlxModel(fullPath, entry.name, sizeBytes, sourceLabel, rootDir));
+          const caps = await detectMlxCapabilities(fullPath);
+          models.push(makeMlxModel(fullPath, entry.name, sizeBytes, sourceLabel, rootDir, caps.contextLength));
         } else {
           await walk(fullPath, depth + 1);
         }
@@ -155,6 +157,7 @@ async function scanHfHubForMlx(dir, sourceLabel) {
         path: snapshotPath,
         filePath: snapshotPath,
         sizeBytes,
+        contextLength: (await detectMlxCapabilities(snapshotPath)).contextLength,
         backend: "mlx-vlm",
         format: "mlx",
         source: sourceLabel,
@@ -185,13 +188,14 @@ async function isEmbeddingMlxModel(configPath) {
 
 // ── MLX model entry builder ───────────────────────────────────────────────
 
-function makeMlxModel(dir, label, sizeBytes, sourceLabel, rootDir) {
+function makeMlxModel(dir, label, sizeBytes, sourceLabel, rootDir, contextLength = null) {
   return {
     id: `${sourceLabel}:${dir.replace(rootDir + "/", "")}`,
     label,
     path: dir,
     filePath: dir,
     sizeBytes,
+    contextLength,
     backend: "mlx-vlm",
     format: "mlx",
     source: sourceLabel,
@@ -287,4 +291,51 @@ export function defaultMlxContextLength(trainedCtx, ramGb) {
   if (ramGb < 16) return Math.min(trainedCtx, 8192);
   if (ramGb < 32) return Math.min(trainedCtx, 16384);
   return trainedCtx;
+}
+
+// ── oMLX model size lookup (from disk) ────────────────────────────────────
+
+/**
+ * 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.
+ */
+export async function scanOmlxModelSizes() {
+  if (!existsSync(OMLX_MODELS_DIR)) return new Map();
+  const sizeByBasename = new Map();
+
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const fullPath = join(dir, entry.name);
+      if (await isMlxModelDir(fullPath)) {
+        const sizeBytes = await getMlxDirSizeBytes(fullPath);
+        if (sizeBytes > 0) sizeByBasename.set(entry.name, sizeBytes);
+      } else {
+        await walk(fullPath);
+      }
+    }
+  }
+
+  await walk(OMLX_MODELS_DIR);
+  return sizeByBasename;
+}
+
+/**
+ * Look up a model's size 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);
+  const dashIdx = modelId.indexOf("--");
+  if (dashIdx >= 0 && sizeMap.has(modelId.slice(dashIdx + 2))) return sizeMap.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));
+  return null;
 }

package/src/model-catalog.mjs

@@ -3,6 +3,7 @@ import { loadProfiles, normalizeProfile, sanitizeProfileId } from "./profiles.mj
 import { scanManagedModels } from "./managed.mjs";
 import { scanMlxModels } from "./mlx-discovery.mjs";
 import { isProfileFileMissing } from "./model-summary.mjs";
+import { backendFor } from "./backends.mjs";
 
 export async function loadModelCatalog() {
   const [profiles, { models: ggufModels, drafters }, managedModels, mlxModels] = await Promise.all([
@@ -34,7 +35,7 @@ export function normalizeCatalog(catalog) {
       if (!profiledAliases.has(`${backendId}:${model.id}`)) managedItems.push({ model, backendId });
     }
   }
-  return { profiles, ggufModels, drafters, managedModels, newModels, managedItems };
+  return { profiles, ggufModels, drafters, managedModels, mlxModels, newModels, managedItems };
 }
 
 export function itemKey(item) {
@@ -56,13 +57,73 @@ function compareRecency(a, b) {
 }
 
 export function buildCatalogItems(normalized) {
-  const { profiles, newModels, managedItems, drafters } = normalized;
-  const profileItems = profiles.map((profile) => ({ type: "profile", profile, label: profile.label, fileMissing: isProfileFileMissing(profile) }));
+  const { profiles, newModels, managedItems, drafters, ggufModels = [], mlxModels = [], managedModels = [] } = normalized;
+
+  // Lookup maps for enriching profile items with scan data (size + context).
+  const scanByPath = new Map();
+  for (const m of ggufModels) scanByPath.set(m.path, m);
+  for (const m of mlxModels) scanByPath.set(m.filePath ?? m.path, m);
+
+  const managedByKey = new Map();
+  for (const { backendId, models } of managedModels) {
+    for (const m of models) managedByKey.set(`${backendId}:${m.id}`, m);
+  }
+
+  const profileItems = profiles.map((profile) => {
+    const item = { type: "profile", profile, label: profile.label, fileMissing: isProfileFileMissing(profile) };
+
+    // Resolve size: profile.modelSizeBytes → scan lookup → managed lookup
+    let sizeBytes = profile.modelSizeBytes || 0;
+    if (!sizeBytes && profile.modelPath) {
+      const scanModel = scanByPath.get(profile.modelPath);
+      if (scanModel?.sizeBytes) sizeBytes = scanModel.sizeBytes;
+    }
+    if (!sizeBytes) {
+      const backend = backendFor(profile.backend);
+      if (backend.type === "managed-server" && profile.omlxModel) {
+        const managedModel = managedByKey.get(`${profile.backend}:${profile.omlxModel}`);
+        if (managedModel?.sizeBytes) sizeBytes = managedModel.sizeBytes;
+      }
+    }
+    item.sizeBytes = sizeBytes || null;
+
+    // Resolve context: flags.ctxSize (configured) → capabilities.ctxSize (trained) → scan → managed
+    let contextLength = profile.flags?.ctxSize ?? null;
+    if (!contextLength) contextLength = profile.capabilities?.ctxSize ?? null;
+    if (!contextLength && profile.modelPath) {
+      const scanModel = scanByPath.get(profile.modelPath);
+      if (scanModel?.contextLength) contextLength = scanModel.contextLength;
+    }
+    if (!contextLength) {
+      const backend = backendFor(profile.backend);
+      if (backend.type === "managed-server" && profile.omlxModel) {
+        const managedModel = managedByKey.get(`${profile.backend}:${profile.omlxModel}`);
+        if (managedModel?.contextLength) contextLength = managedModel.contextLength;
+      }
+    }
+    item.contextLength = contextLength;
+
+    return item;
+  });
   profileItems.sort(compareRecency);
   return [
     ...profileItems,
-    ...newModels.map((model) => ({ type: "new", model, label: model.label, drafter: matchDrafter(model.path, drafters) })),
-    ...managedItems.map(({ model, backendId }) => ({ type: "managed", model, backendId, label: model.label })),
+    ...newModels.map((model) => ({
+      type: "new",
+      model,
+      label: model.label,
+      drafter: matchDrafter(model.path, drafters),
+      sizeBytes: model.sizeBytes || null,
+      contextLength: model.contextLength ?? null,
+    })),
+    ...managedItems.map(({ model, backendId }) => ({
+      type: "managed",
+      model,
+      backendId,
+      label: model.label,
+      sizeBytes: model.sizeBytes || null,
+      contextLength: model.contextLength ?? null,
+    })),
   ];
 }
 

package/src/model-presenters.mjs

@@ -11,7 +11,7 @@ import { DATA_DIR } from "./config.mjs";
 import { findBenchmarkRepo } from "./benchmark.mjs";
 
 const OPTION_SEPARATOR = pc.dim("  │  ");
-const OPTION_STATUS_WIDTH = 10;
+const OPTION_STATUS_WIDTH = 12;
 const OPTION_BACKEND_WIDTH = 14;
 const OPTION_SOURCE_WIDTH = 14;
 const OPTION_CTX_WIDTH = 5;
@@ -30,7 +30,7 @@ function optionStatusTag(kind) {
     serverup: ["READY", pc.blue],
     ready: ["READY", pc.blue],
     missing: ["MISSING", pc.red],
-    setup: ["SETUP", pc.yellow],
+    setup: ["NEEDS SETUP", pc.yellow],
   };
   const [text, color] = statuses[kind] ?? [kind, pc.dim];
   return optionPad(text, color, OPTION_STATUS_WIDTH);
@@ -101,32 +101,18 @@ function discoverySourceForItem(item) {
 }
 
 function optionCtxLabel(item) {
-  if (item.type === "profile" && item.profile.flags?.ctxSize) {
-    return optionPad(`${(item.profile.flags.ctxSize / 1000).toFixed(0)}k`, null, OPTION_CTX_WIDTH);
+  // Context window is a configured value — only profiles (READY/RUNNING)
+  // have one. SETUP items (new/managed) show "—".
+  if (item.type !== "profile") return optionPad("—", null, OPTION_CTX_WIDTH);
+  if (item.contextLength) {
+    return optionPad(`${(item.contextLength / 1000).toFixed(0)}k`, null, OPTION_CTX_WIDTH);
   }
   return optionPad("—", null, OPTION_CTX_WIDTH);
 }
 
-function optionSizeLabel(item, managedModels) {
-  if (item.type === "profile") {
-    if (item.fileMissing) return "—";
-    if (item.profile.modelSizeBytes) return formatBytes(item.profile.modelSizeBytes);
-    if (item.profile.modelPath && existsSync(item.profile.modelPath)) {
-      const s = statSync(item.profile.modelPath);
-      // Only stat regular files — a modelPath that is a directory (MLX)
-      // reports the dir entry size, not the model size.
-      if (s.isFile()) return formatBytes(s.size);
-    }
-    const managedSize = managedProfileSizeBytes(item.profile, managedModels);
-    if (managedSize) return formatBytes(managedSize);
-    return "—";
-  }
-  if (item.type === "new") {
-    return formatBytes(item.model.sizeBytes);
-  }
-  // managed
-  if (item.model.sizeBytes) return formatBytes(item.model.sizeBytes);
-  if (item.model.quant) return item.model.quant;
+function optionSizeLabel(item) {
+  if (item.type === "profile" && item.fileMissing) return "—";
+  if (item.sizeBytes) return formatBytes(item.sizeBytes);
   return "—";
 }
 
@@ -141,7 +127,7 @@ 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);
 }
 
-export function modelSelectOption(item, { runningProfilesNow, modelMissingIds, nameWidth, managedModels }) {
+export function modelSelectOption(item, { runningProfilesNow, modelMissingIds, nameWidth }) {
   const sourceId = discoverySourceForItem(item) ?? "unknown";
   const backendId = inferBackendId(item);
   if (item.type === "profile") {
@@ -162,7 +148,7 @@ export function modelSelectOption(item, { runningProfilesNow, modelMissingIds, n
         name: item.profile.label,
         nameWidth,
         ctx: optionCtxLabel(item),
-        size: optionSizeLabel(item, managedModels),
+        size: optionSizeLabel(item),
       }),
       ...(hint ? { hint: pc.red(hint) } : {}),
     };
@@ -177,7 +163,7 @@ export function modelSelectOption(item, { runningProfilesNow, modelMissingIds, n
         name: item.model.label,
         nameWidth,
         ctx: optionCtxLabel(item),
-        size: optionSizeLabel(item, managedModels),
+        size: optionSizeLabel(item),
       }),
     };
   }
@@ -190,22 +176,11 @@ export function modelSelectOption(item, { runningProfilesNow, modelMissingIds, n
       name: item.model.label,
       nameWidth,
       ctx: optionCtxLabel(item),
-      size: optionSizeLabel(item, managedModels),
+      size: optionSizeLabel(item),
     }),
   };
 }
 
-function managedProfileSizeBytes(profile, managedModels) {
-  if (!managedModels || !Array.isArray(managedModels)) return null;
-  const backend = backendFor(profile.backend);
-  if (backend.type !== "managed-server") return null;
-  const backendModels = managedModels.find((m) => m.backendId === profile.backend)?.models ?? [];
-  const modelId = profile.omlxModel ?? null;
-  if (!modelId) return null;
-  const model = backendModels.find((m) => m.id === modelId);
-  return model?.sizeBytes || null;
-}
-
 function inferBackendId(item) {
   if (item.type === "profile") return item.profile.backend;
   if (item.type === "managed") return item.backendId;
@@ -266,7 +241,7 @@ export async function printProfileDetails(profile) {
     detailRows.push(
       ["Local file", fileMissing ? pc.red(`${profile.modelPath} (not found)`) : profile.modelPath ?? "unknown"],
       ["Vision file", profile.mmprojPath ? (existsSync(profile.mmprojPath) ? profile.mmprojPath : pc.red(`${profile.mmprojPath} (not found)`)) : "none"],
-      ["Model size", profile.modelPath && existsSync(profile.modelPath) ? formatBytes(statSync(profile.modelPath).size) : "unknown"],
+      ["Model size", profile.modelSizeBytes ? formatBytes(profile.modelSizeBytes) : (profile.modelPath && existsSync(profile.modelPath) && statSync(profile.modelPath).isFile() ? formatBytes(statSync(profile.modelPath).size) : "unknown")],
     );
     if (profile.drafterPath) {
       detailRows.push(["Drafter", existsSync(profile.drafterPath) ? profile.drafterPath : pc.red(`${profile.drafterPath} (not found)`)]);

package/src/scan.mjs

@@ -57,6 +57,9 @@ async function scanOneDir(root, sourceLabel = "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;
+    const contextLength = architecture && typeof meta[`${architecture}.context_length`] === "number"
+      ? meta[`${architecture}.context_length`]
+      : null;
 
     if (isEmbeddingArchitecture(architecture, name)) continue;
 
@@ -81,6 +84,7 @@ async function scanOneDir(root, sourceLabel = "local-gguf") {
         aliasSuggestion: parsed.id,
         quant: parsed.quant,
         sizeBytes,
+        contextLength,
         backend: "llama-cpp",
         source: sourceLabel,
       });