offgrid-ai 0.6.5 → 0.6.7

package/src/commands/stop.mjs

@@ -0,0 +1,64 @@
+import { ensureDirs } from "../config.mjs";
+import { readProfile, loadProfiles } from "../profiles.mjs";
+import { stopProfile, profileRuntimeStatus } from "../process.mjs";
+import { pc, startInteractive, createPrompt, parseOptions } from "../ui.mjs";
+
+export async function stopCommand(argv) {
+  await ensureDirs();
+  const { positional, options } = parseOptions(argv);
+
+  if (options.all) return stopAll();
+  if (positional[0]) return stopOne(positional[0]);
+
+  const running = await runningProfiles();
+  if (running.length === 0) {
+    console.log(pc.dim("No offgrid-ai servers are running."));
+    return;
+  }
+
+  if (!process.stdin.isTTY) {
+    for (const { profile, status } of running) console.log(`  ${pc.green("●")} ${pc.bold(profile.label)} · pid ${status.pid}`);
+    console.log(pc.dim("Stop with: offgrid-ai stop <id>"));
+    return;
+  }
+
+  startInteractive("offgrid-ai stop");
+  const prompt = createPrompt();
+  try {
+    const choices = running.map(({ profile, status }) => ({ value: profile.id, label: profile.label, hint: `pid ${status.pid} · ${profile.baseUrl}` }));
+    if (running.length > 1) choices.unshift({ value: "__all", label: "Stop all", hint: `${running.length} servers` });
+    choices.push({ value: "__cancel", label: "Cancel" });
+
+    const selected = await prompt.choice("Stop", choices, choices[0].value);
+    if (selected === "__cancel") return;
+
+    const targets = selected === "__all" ? running : running.filter((item) => item.profile.id === selected);
+    for (const { profile } of targets) await printStopResult(profile);
+  } finally {
+    prompt.close();
+  }
+}
+
+export async function stopOne(id) {
+  await printStopResult(await readProfile(id));
+}
+
+export async function stopAll() {
+  const running = await runningProfiles();
+  if (running.length === 0) {
+    console.log(pc.dim("No offgrid-ai servers are running."));
+    return;
+  }
+  for (const { profile } of running) await printStopResult(profile);
+}
+
+export async function runningProfiles() {
+  const profiles = await loadProfiles();
+  const statuses = await Promise.all(profiles.map(async (profile) => ({ profile, status: await profileRuntimeStatus(profile) })));
+  return statuses.filter((item) => item.status.running);
+}
+
+async function printStopResult(profile) {
+  const result = await stopProfile(profile);
+  console.log(result.stopped ? pc.green(result.message) : pc.yellow(result.message));
+}

package/src/commands/uninstall.mjs

@@ -0,0 +1,96 @@
+import { existsSync, rmSync } from "node:fs";
+import { DATA_DIR } from "../config.mjs";
+import { removeInstallerPathEntries } from "../shell-path.mjs";
+import { stopProfile } from "../process.mjs";
+import { runCommand } from "../exec.mjs";
+import { pc, startInteractive, createPrompt, parseOptions } from "../ui.mjs";
+import { runningProfiles } from "./stop.mjs";
+
+export async function uninstallCommand(argv) {
+  const { options } = parseOptions(argv);
+  const force = options.force || options.f;
+
+  if (!process.stdin.isTTY && !force) throw new Error("Non-interactive uninstall requires --force to avoid accidental data loss.");
+
+  if (force) {
+    await stopTrackedServers();
+    await removeDataDir();
+    await removeShellPath();
+    await removeSelf();
+    return;
+  }
+
+  startInteractive("offgrid-ai uninstall");
+  const prompt = createPrompt();
+  try {
+    console.log(pc.bold("offgrid-ai uninstall\n"));
+    const running = await runningProfiles();
+    if (running.length > 0) {
+      console.log(pc.yellow(`${running.length} server(s) still running. Stopping...`));
+      for (const { profile } of running) await stopProfile(profile);
+      console.log(pc.green("All servers stopped."));
+    }
+
+    const mode = await prompt.choice("Choose uninstall type", [
+      { value: "keep-data", label: "Uninstall app only", hint: `keep profiles and settings in ${DATA_DIR}` },
+      { value: "delete-data", label: "Full uninstall", hint: "delete profiles/settings, then uninstall app" },
+      { value: "cancel", label: "Cancel" },
+    ], "keep-data");
+
+    if (mode === "cancel") {
+      console.log(pc.dim("Cancelled."));
+      return;
+    }
+
+    if (mode === "delete-data") await removeDataDir();
+    else console.log(pc.dim(`Keeping ${DATA_DIR} for when you reinstall.`));
+
+    await removeShellPath();
+    await removeSelf();
+  } finally {
+    prompt.close();
+  }
+}
+
+async function stopTrackedServers() {
+  const running = await runningProfiles();
+  for (const { profile } of running) {
+    const result = await stopProfile(profile);
+    console.log(result.stopped ? pc.green(`✓ ${result.message}`) : pc.dim(result.message));
+  }
+}
+
+async function removeDataDir() {
+  if (existsSync(DATA_DIR)) {
+    try {
+      rmSync(DATA_DIR, { recursive: true, force: true });
+      console.log(pc.green(`✓ Removed ${DATA_DIR}`));
+    } catch (err) {
+      console.log(pc.red(`Failed to remove ${DATA_DIR}: ${err.message}`));
+      console.log(pc.dim(`Remove it manually: rm -rf ${DATA_DIR}`));
+    }
+  } else {
+    console.log(pc.dim(`${DATA_DIR} doesn't exist — already clean.`));
+  }
+}
+
+async function removeShellPath() {
+  const cleaned = await removeInstallerPathEntries();
+  if (cleaned.length === 0) {
+    console.log(pc.dim("No offgrid-ai PATH entries found in shell configs."));
+    return;
+  }
+  for (const rcFile of cleaned) console.log(pc.green(`✓ Cleaned PATH from ${rcFile}`));
+}
+
+async function removeSelf() {
+  console.log(pc.cyan("\nUninstalling offgrid-ai..."));
+  try {
+    await runCommand("npm", ["uninstall", "-g", "offgrid-ai"], { label: "npm uninstall", verbose: process.argv.includes("--verbose") });
+    console.log(pc.green("\n✓ offgrid-ai has been uninstalled."));
+    console.log(pc.dim("Reinstall anytime with: npm install -g offgrid-ai@latest --prefer-online"));
+  } catch {
+    console.log(pc.red("\n✗ Could not auto-uninstall. Run this manually:"));
+    console.log(pc.bold("  npm uninstall -g offgrid-ai"));
+  }
+}

package/src/exec.mjs

@@ -0,0 +1,31 @@
+import { spawn } from "node:child_process";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+export const execFileAsync = promisify(execFile);
+
+export function runCommand(cmd, args, { label = cmd, verbose = false } = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, { stdio: verbose ? "inherit" : ["ignore", "pipe", "pipe"] });
+    let stderr = "";
+    if (!verbose) child.stderr?.on("data", (data) => { stderr += data; });
+    child.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(lastStderrLines(stderr) || `${label} exited with code ${code}`));
+    });
+    child.on("error", reject);
+  });
+}
+
+export async function commandExists(name) {
+  try {
+    await execFileAsync("which", [name]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function lastStderrLines(stderr) {
+  return String(stderr).split("\n").filter((line) => line.trim()).slice(-3).join("\n");
+}

package/src/managed.mjs

@@ -0,0 +1,31 @@
+import { existsSync } from "node:fs";
+import { BACKENDS } from "./backends.mjs";
+import { commandExists } from "./exec.mjs";
+
+export const MANAGED_BACKEND_IDS = ["ollama", "omlx"];
+
+export async function scanManagedModels() {
+  const results = [];
+  for (const backendId of MANAGED_BACKEND_IDS) {
+    const backend = BACKENDS[backendId];
+    try {
+      const models = await backend.scanModels();
+      results.push({ backendId, models });
+    } catch {
+      // Managed backends are optional and may not be running.
+    }
+  }
+  return results;
+}
+
+export function hasLmStudioInstalled() {
+  return existsSync("/Applications/LM Studio.app");
+}
+
+export function hasOllamaInstalled() {
+  return commandExists("ollama");
+}
+
+export function hasOmlxInstalled() {
+  return commandExists("omlx");
+}

package/src/model-catalog.mjs

@@ -0,0 +1,58 @@
+import { scanGgufModels, matchDrafter } from "./scan.mjs";
+import { loadProfiles, normalizeProfile, sanitizeProfileId } from "./profiles.mjs";
+import { scanManagedModels } from "./managed.mjs";
+import { isProfileFileMissing } from "./model-summary.mjs";
+
+export async function loadModelCatalog() {
+  const [profiles, { models: ggufModels, drafters }, managedModels] = await Promise.all([
+    loadProfiles(),
+    scanGgufModels(),
+    scanManagedModels(),
+  ]);
+  return normalizeCatalog({ profiles, ggufModels, drafters, managedModels });
+}
+
+export function normalizeCatalog(catalog) {
+  if (catalog.newModels && catalog.managedItems) return catalog;
+  const { profiles, ggufModels, drafters, managedModels } = 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) {
+    const profiledAliases = new Set(
+      profiles
+        .filter((profile) => profile.backend === backendId)
+        .map((profile) => backendId === "ollama" ? `ollama:${profile.ollamaModel ?? profile.modelAlias}` : `omlx:${profile.omlxModel ?? profile.modelAlias}`),
+    );
+    for (const model of models) {
+      if (!profiledAliases.has(`${backendId}:${model.id}`)) managedItems.push({ model, backendId });
+    }
+  }
+  return { profiles, ggufModels, drafters, managedModels, newModels, managedItems };
+}
+
+export function itemKey(item) {
+  if (item.type === "profile") return `profile:${item.profile.id}`;
+  if (item.type === "new") return `new:${item.model.path}`;
+  return `managed:${item.backendId}:${item.model.id}`;
+}
+
+export function buildCatalogItems(normalized) {
+  const { profiles, newModels, managedItems, drafters } = normalized;
+  return [
+    ...profiles.map((profile) => ({ type: "profile", profile, label: profile.label, fileMissing: isProfileFileMissing(profile) })),
+    ...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 })),
+  ];
+}
+
+export function createManagedProfile(model, backendId) {
+  return normalizeProfile({
+    id: `${backendId}-${sanitizeProfileId(model.id)}`,
+    label: model.label,
+    backend: backendId,
+    modelAlias: model.aliasSuggestion,
+    ...(backendId === "ollama" ? { ollamaModel: model.id } : {}),
+    ...(backendId === "omlx" ? { omlxModel: model.id } : {}),
+  });
+}

package/src/model-presenters.mjs

@@ -0,0 +1,190 @@
+import { existsSync, statSync } from "node:fs";
+import { BACKENDS, backendFor } from "./backends.mjs";
+import { readCommandArgv } from "./profiles.mjs";
+import { isProfileRunning } from "./process.mjs";
+import { detectCapabilities } from "./autodetect.mjs";
+import { buildPrettyCommand } from "./command.mjs";
+import { pc, formatBytes, renderRows, renderSection, renderCard } from "./ui.mjs";
+import { capabilitySummary, ggufDetailParts, ggufMtpLabel, isProfileFileMissing, profileDetailParts, profileMtpLabel } from "./model-summary.mjs";
+import { itemKey } from "./model-catalog.mjs";
+
+const OPTION_SEPARATOR = pc.dim("  │  ");
+const OPTION_STATUS_WIDTH = 12;
+const OPTION_SOURCE_WIDTH = 14;
+
+function optionTag(text, color, width) {
+  const padded = String(text).padEnd(width);
+  return color ? color(padded) : padded;
+}
+
+function optionStatusTag(kind) {
+  const statuses = {
+    running: ["RUNNING", pc.green],
+    ready: ["READY", pc.green],
+    missing: ["FILE MISSING", pc.red],
+    setup: ["NEEDS SETUP", pc.yellow],
+  };
+  const [text, color] = statuses[kind] ?? [kind, pc.dim];
+  return optionTag(text, color, OPTION_STATUS_WIDTH);
+}
+
+function optionSourceTag(sourceId, label) {
+  const colors = {
+    "llama-cpp": pc.cyan,
+    "llama-cpp-mtp": pc.blue,
+    ollama: pc.green,
+    omlx: pc.magenta,
+    gguf: pc.cyan,
+  };
+  return optionTag(label, colors[sourceId] ?? pc.dim, OPTION_SOURCE_WIDTH);
+}
+
+function optionLabel({ status, source, name, details = [] }) {
+  return [status, source, pc.bold(name), ...details].filter(Boolean).join(OPTION_SEPARATOR);
+}
+
+export function modelSelectOption(item, { runningProfilesNow }) {
+  if (item.type === "profile") {
+    const backend = backendFor(item.profile.backend);
+    const running = runningProfilesNow.some((profile) => profile.id === item.profile.id);
+    return {
+      value: itemKey(item),
+      label: optionLabel({
+        status: optionStatusTag(item.fileMissing ? "missing" : running ? "running" : "ready"),
+        source: optionSourceTag(item.profile.backend, backend.label),
+        name: item.profile.label,
+      }),
+    };
+  }
+  if (item.type === "new") {
+    return {
+      value: itemKey(item),
+      label: optionLabel({ status: optionStatusTag("setup"), source: optionSourceTag("gguf", "GGUF file"), name: item.model.label }),
+    };
+  }
+  const backend = BACKENDS[item.backendId];
+  return {
+    value: itemKey(item),
+    label: optionLabel({ status: optionStatusTag("setup"), source: optionSourceTag(item.backendId, backend.label), name: item.model.label }),
+  };
+}
+
+export function printModelCards(items, { runningProfilesNow, drafters }) {
+  const profiles = items.filter((item) => item.type === "profile");
+  const newModels = items.filter((item) => item.type === "new");
+  const managed = items.filter((item) => item.type === "managed");
+
+  if (profiles.length > 0) {
+    console.log("\n" + pc.bold("Ready to chat"));
+    for (const item of profiles) {
+      const { profile } = item;
+      const backend = backendFor(profile.backend);
+      const running = runningProfilesNow.some((runningProfile) => runningProfile.id === profile.id);
+      const status = item.fileMissing ? pc.red("File missing") : running ? pc.green("Running now") : "Ready";
+      const border = item.fileMissing ? pc.red : running ? pc.green : pc.dim;
+      const detailParts = [item.fileMissing ? pc.red("File not found") : profileDetailParts(profile, { drafters }).filter(Boolean)[0]];
+      const mtpLabel = profileMtpLabel(profile, drafters);
+      if (mtpLabel) detailParts.push(mtpLabel);
+      const ctxLabel = profile.flags?.ctxSize ? `${(profile.flags.ctxSize / 1000).toFixed(0)}k ctx` : null;
+      if (ctxLabel) detailParts.push(ctxLabel);
+      console.log(renderCard(profile.label, renderRows([
+        ["Status", status],
+        ["Details", detailParts.join(pc.dim(" · "))],
+        ["Runs with", backend.label],
+      ]), { formatBorder: border }));
+    }
+  }
+
+  if (newModels.length > 0) {
+    console.log("\n" + pc.bold("Needs setup"));
+    for (const item of newModels) {
+      const caps = detectCapabilities(item.model.path, item.model.mmprojPath);
+      const detailParts = [capabilitySummary(caps)];
+      const mtpLabel = ggufMtpLabel(item.model, item.drafter);
+      if (mtpLabel) detailParts.push(mtpLabel);
+      detailParts.push(formatBytes(item.model.sizeBytes));
+      console.log(renderCard(item.model.label, renderRows([
+        ["Status", pc.yellow("Needs setup")],
+        ["Details", detailParts.join(pc.dim(" · "))],
+      ]), { formatBorder: pc.yellow }));
+    }
+  }
+
+  for (const backendId of ["ollama", "omlx"]) {
+    const managedForBackend = managed.filter((item) => item.backendId === backendId);
+    if (managedForBackend.length === 0) continue;
+    const backend = BACKENDS[backendId];
+    console.log("\n" + pc.bold(`Via ${backend.label}`));
+    for (const item of managedForBackend) {
+      console.log(renderCard(item.model.label, renderRows([
+        ["Details", [item.model.id, item.model.quant].filter(Boolean).join(pc.dim(" · "))],
+      ]), { formatBorder: pc.dim }));
+    }
+  }
+}
+
+export async function printProfileDetails(profile) {
+  const backend = backendFor(profile.backend);
+  const isManaged = backend.type === "managed-server";
+  const running = await isProfileRunning(profile);
+  const fileMissing = !isManaged && isProfileFileMissing(profile);
+  console.log("\n" + renderSection("Model overview", renderRows([
+    ["Name", pc.bold(profile.label)],
+    ["Status", fileMissing ? pc.red("File missing") : running ? pc.green("Running now") : "Ready"],
+    ["Details", profileDetailParts(profile, { fileMissing }).join(pc.dim(" · "))],
+    ["Server", fileMissing ? pc.red(profile.baseUrl) : profile.baseUrl],
+  ])));
+
+  const detailRows = [
+    ["Setup ID", profile.id],
+    ["Runs with", backend.label],
+    ["Model alias", profile.modelAlias],
+    ...(profile.capabilities ? [["Detected", capabilitySummary(profile.capabilities)]] : []),
+  ];
+  if (!isManaged) {
+    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"],
+    );
+    if (profile.drafterPath) {
+      detailRows.push(["Drafter", existsSync(profile.drafterPath) ? profile.drafterPath : pc.red(`${profile.drafterPath} (not found)`)]);
+    }
+  }
+  console.log("\n" + renderSection("Model details", renderRows(detailRows), { columns: 110 }));
+
+  if (fileMissing) console.log("\n" + pc.red("⚠ This model's file is no longer on disk. Remove this setup or move the file back."));
+
+  if (!isManaged && profile.commandArgv) {
+    const commandArgv = await readCommandArgv(profile);
+    console.log("\n" + renderSection("llama-server command", pc.dim(buildPrettyCommand({ ...profile, commandArgv })), { columns: 120 }));
+  }
+}
+
+export function printGgufModelDetails(model, drafter) {
+  const { caps, parts } = ggufDetailParts(model, drafter);
+  parts.push(formatBytes(model.sizeBytes));
+  console.log("\n" + renderSection("Downloaded model", renderRows([
+    ["Name", pc.bold(model.label)],
+    ["Status", pc.yellow("Needs one-time setup")],
+    ["Details", parts.join(pc.dim(" · "))],
+  ])));
+  const detailRows = [
+    ["Local file", model.path],
+    ["Vision file", model.mmprojPath ?? "none"],
+    ["Detected", capabilitySummary(caps)],
+    ["Quant", model.quant ?? "unknown"],
+  ];
+  if (drafter) detailRows.push(["Drafter", drafter.path], ["Drafter size", formatBytes(drafter.sizeBytes)]);
+  console.log("\n" + renderSection("Model details", renderRows(detailRows), { columns: 110 }));
+}
+
+export function printManagedModelDetails(model, backend) {
+  console.log("\n" + renderSection(`${backend.label} model`, renderRows([
+    ["Name", pc.bold(model.label)],
+    ["Status", pc.green(`Local model via ${backend.label}`)],
+    ["Model ID", pc.cyan(model.id)],
+    ["Quant", model.quant ?? "unknown"],
+    ["Family", model.family ?? "unknown"],
+  ])));
+}

package/src/model-summary.mjs

@@ -0,0 +1,61 @@
+import { existsSync } from "node:fs";
+import { basename } from "node:path";
+import { backendFor } from "./backends.mjs";
+import { matchDrafter } from "./scan.mjs";
+import { detectCapabilities } from "./autodetect.mjs";
+import { pc, humanCapabilitySummary } from "./ui.mjs";
+
+export function isProfileFileMissing(profile) {
+  const backend = backendFor(profile.backend);
+  if (backend.type === "managed-server") return false;
+  if (!profile.modelPath) return true;
+  return !existsSync(profile.modelPath);
+}
+
+export function capabilitySummary(caps) {
+  const parts = [];
+  if (caps.architecture) parts.push(caps.architecture);
+  if (caps.quant) parts.push(caps.quant);
+  if (caps.mtp) parts.push("MTP");
+  if (caps.qat) parts.push("QAT");
+  if (caps.thinking) parts.push("thinking");
+  if (caps.vision) parts.push("vision");
+  return parts.length > 0 ? parts.join(" · ") : "standard GGUF";
+}
+
+export function profileMtpLabel(profile, drafters, { detailed = false } = {}) {
+  if (profile.drafterPath) {
+    return detailed ? pc.green(`MTP enabled (drafter: ${basename(profile.drafterPath)})`) : pc.green("MTP enabled");
+  }
+  if (drafters && profile.modelPath && matchDrafter(profile.modelPath, drafters)) return pc.yellow("MTP available");
+  if (profile.capabilities?.architecture === "gemma4") {
+    return detailed ? pc.yellow("MTP available — download a drafter model to enable 2× speedup") : pc.yellow("MTP: needs drafter");
+  }
+  return null;
+}
+
+export function ggufMtpLabel(model, drafter) {
+  const caps = detectCapabilities(model.path, model.mmprojPath);
+  if (caps.mtp || Boolean(drafter)) return pc.green("MTP ✓");
+  if (caps.architecture === "gemma4") return pc.yellow("MTP: needs drafter");
+  return null;
+}
+
+export function profileDetailParts(profile, { fileMissing = false, drafters = null } = {}) {
+  const parts = [fileMissing ? pc.red("File not found") : humanCapabilitySummary(profile.capabilities ?? {})];
+  const mtpLabel = profileMtpLabel(profile, drafters, { detailed: true });
+  if (mtpLabel) parts.push(mtpLabel);
+  const ctxLabel = profile.flags?.ctxSize ? `${(profile.flags.ctxSize / 1000).toFixed(0)}k ctx` : null;
+  if (ctxLabel) parts.push(ctxLabel);
+  return parts;
+}
+
+export function ggufDetailParts(model, drafter) {
+  const caps = detectCapabilities(model.path, model.mmprojPath);
+  const parts = [humanCapabilitySummary(caps)];
+  const mtpLabel = ggufMtpLabel(model, drafter);
+  if (mtpLabel) parts.push(mtpLabel);
+  const ctxLabel = caps.ctxSize ? `${(caps.ctxSize / 1000).toFixed(0)}k ctx` : null;
+  if (ctxLabel) parts.push(ctxLabel);
+  return { caps, parts };
+}

package/src/profile-setup.mjs

@@ -34,16 +34,14 @@ export async function configureLocalProfile(prompt, profile) {
   let configured = profile;
   // Re-detect capabilities from the model file and check for drafters
   // so that re-setup can pick up MTP availability, vision changes, etc.
-  const hfSource = profile.hfRepo ? { hfRepo: profile.hfRepo, hfVariant: profile.hfVariant } : {};
-  const freshCaps = { ...detectCapabilities(profile.modelPath, profile.mmprojPath), ...hfSource };
+  const freshCaps = detectCapabilities(profile.modelPath, profile.mmprojPath);
   let drafterPath = profile.drafterPath ?? null;
-  if (!drafterPath && !profile.hfRepo) {
+  if (!drafterPath) {
     const { drafters } = await scanGgufModels();
     const drafter = matchDrafter(profile.modelPath, drafters);
     if (drafter) drafterPath = drafter.path;
   }
-  const hfGemma4Mtp = Boolean(profile.hfRepo && /gemma-?4/i.test(`${profile.hfRepo} ${profile.label}`));
-  const hasMtp = freshCaps.mtp || Boolean(drafterPath) || hfGemma4Mtp;
+  const hasMtp = freshCaps.mtp || Boolean(drafterPath);
   const caps = { ...freshCaps, mtp: hasMtp };
   // If MTP is newly available, switch backend and add drafter path
   if (hasMtp && configured.backend !== "llama-cpp-mtp") {
@@ -73,7 +71,7 @@ export async function configureLocalProfile(prompt, profile) {
     console.log(renderSection("MTP detected", renderRows([
       ["Backend", "llama.cpp MTP"],
       ["Port", String(LLAMA_CPP_MTP_PORT)],
-      ["Flags", `--spec-type draft-mtp --spec-draft-n-max 4${configured.drafterPath && !configured.hfRepo ? " --spec-draft-model <drafter>" : ""}`],
+      ["Flags", `--spec-type draft-mtp --spec-draft-n-max 4${configured.drafterPath ? " --spec-draft-model <drafter>" : ""}`],
     ])));
     if (drafterInfo) console.log(pc.dim(drafterInfo));
     const useMtp = await prompt.yesNo("Use MTP speculative decoding?", true);
@@ -139,20 +137,29 @@ export function applyRuntimeFlagOverrides(profile, overrides) {
   return applyProfileFlags(profile, flags);
 }
 
-function applyMtpDefaults(profile) {
+export function applyMtpDefaults(profile) {
   const flags = { ...profile.flags, port: LLAMA_CPP_MTP_PORT };
   const edits = {
     values: { "--spec-type": "draft-mtp", "--spec-draft-n-max": 4 },
   };
-  if (profile.drafterPath && !profile.hfRepo) {
-    edits.values["--spec-draft-model"] = profile.drafterPath;
-  }
-  return applyProfileFlags({ ...profile, backend: "llama-cpp-mtp", providerId: "llama-cpp-mtp" }, flags, edits);
+  if (profile.drafterPath) edits.values["--spec-draft-model"] = profile.drafterPath;
+  return applyProfileFlags({
+    ...profile,
+    backend: "llama-cpp-mtp",
+    providerId: "llama-cpp-mtp",
+    capabilities: { ...(profile.capabilities ?? {}), mtp: true },
+  }, flags, edits);
 }
 
-function removeMtpDefaults(profile) {
+export function removeMtpDefaults(profile) {
   const flags = { ...profile.flags, port: LLAMA_CPP_PORT };
-  return applyProfileFlags({ ...profile, backend: "llama-cpp", providerId: "llama-cpp" }, flags, {
+  return applyProfileFlags({
+    ...profile,
+    backend: "llama-cpp",
+    providerId: "llama-cpp",
+    drafterPath: null,
+    capabilities: { ...(profile.capabilities ?? {}), mtp: false },
+  }, flags, {
     remove: ["--spec-type", "--spec-draft-n-max", "--spec-draft-model"],
   });
 }

package/src/profiles.mjs

@@ -134,15 +134,11 @@ export function normalizeProfile(profile) {
 export async function createProfileFromModel(model, backendId, drafterPath) {
   const { detectCapabilities } = await import("./autodetect.mjs");
   const caps = detectCapabilities(model.path, model.mmprojPath);
-  // If a drafter is provided, this model supports MTP regardless of filename.
-  // For Hugging Face Gemma 4 GGUF repos, prefer llama.cpp's -hf companion-file
-  // discovery so root mtp-*.gguf drafters do not need offgrid-ai file matching.
-  const hfGemma4Mtp = Boolean(model.hfRepo && /gemma-?4/i.test(`${model.hfRepo} ${model.label}`));
-  const hasMtp = caps.mtp || Boolean(drafterPath) || hfGemma4Mtp;
+  // If a drafter is provided, this model supports MTP regardless of filename
+  const hasMtp = caps.mtp || Boolean(drafterPath);
   const backend = backendId ?? (hasMtp ? "llama-cpp-mtp" : "llama-cpp");
-  const hfSource = model.hfRepo ? { hfRepo: model.hfRepo, hfVariant: model.hfVariant } : {};
   const { flags, argv } = computeFlags(
-    { ...caps, mtp: hasMtp, ...hfSource },
+    { ...caps, mtp: hasMtp },
     model.path,
     model.mmprojPath,
     drafterPath ?? null,
@@ -154,12 +150,11 @@ export async function createProfileFromModel(model, backendId, drafterPath) {
     backend,
     providerId: backend,
     modelAlias: model.aliasSuggestion,
-    source: model.hfRepo ? "huggingface" : model.source,
+    source: model.source,
     modelPath: model.path,
-    mmprojPath: model.hfRepo ? null : model.mmprojPath,
-    ...hfSource,
+    mmprojPath: model.mmprojPath,
     drafterPath: drafterPath ?? null,
-    capabilities: summarizeCapabilities({ ...caps, mtp: hasMtp, ...hfSource }),
+    capabilities: summarizeCapabilities({ ...caps, mtp: hasMtp }),
     preset: null, // no presets — auto-detected
     flags,
     commandArgv: argv,
@@ -177,8 +172,6 @@ function summarizeCapabilities(caps) {
     quant: caps.quant,
     metaCtx: caps.metaCtx,
     mmprojProjectorType: caps.mmprojProjectorType,
-    hfRepo: caps.hfRepo,
-    hfVariant: caps.hfVariant,
     ctxSize: caps.ctxSize,
   };
 }

package/src/recommendations.mjs

@@ -0,0 +1,17 @@
+import { totalmem } from "node:os";
+
+const MODEL_TIERS = [
+  { maxGB: 8, lms: "google/gemma-4-e2b", ollama: "gemma4:e2b", label: "Gemma 4 E2B (2B effective)" },
+  { maxGB: 16, lms: "google/gemma-4-e4b", ollama: "gemma4:e4b", label: "Gemma 4 E4B (4B effective)" },
+  { maxGB: 32, lms: "qwen/qwen3.5-9b", ollama: "qwen3.5:9b-q4_K_M", label: "Qwen 3.5 9B" },
+  { maxGB: Infinity, lms: "qwen/qwen3.6-35b-a3b", ollama: "qwen3.6:35b-a3b", label: "Qwen 3.6 35B-A3B" },
+];
+
+export function recommendedModel() {
+  const gb = totalmem() / (1024 ** 3);
+  return MODEL_TIERS.find((tier) => gb <= tier.maxGB) ?? MODEL_TIERS[MODEL_TIERS.length - 1];
+}
+
+export function installedRamGB() {
+  return (totalmem() / (1024 ** 3)).toFixed(0);
+}