offgrid-ai 0.10.0 → 0.10.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "offgrid-ai",
-  "version": "0.10.0",
+  "version": "0.10.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

@@ -102,6 +102,7 @@ async function scanOmlxModels() {
       label: parseModelName(model.id, "omlx").display,
       aliasSuggestion: model.id,
       sizeBytes: model.size ?? 0,
+      contextLength: model.max_model_len ?? null,
       quant: null,
       family: null,
       backend: "omlx",

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,

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

@@ -101,32 +101,15 @@ 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);
+  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 +124,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 +145,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 +160,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 +173,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 +238,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,
       });