offgrid-ai 0.6.6 → 0.6.9

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,234 @@
+import { existsSync, statSync } from "node:fs";
+import { BACKENDS, backendFor } from "./backends.mjs";
+import { readCommandArgv } from "./profiles.mjs";
+import { isProfileRunning } from "./process.mjs";
+import { buildPrettyCommand } from "./command.mjs";
+import { pc, formatBytes, renderRows, renderSection } from "./ui.mjs";
+import { capabilitySummary, ggufDetailParts, isProfileFileMissing, profileDetailParts } from "./model-summary.mjs";
+import { itemKey } from "./model-catalog.mjs";
+import { DATA_DIR } from "./config.mjs";
+import { findBenchmarkRepo } from "./benchmark.mjs";
+
+const OPTION_SEPARATOR = pc.dim("  │  ");
+const OPTION_STATUS_WIDTH = 10;
+const OPTION_SOURCE_WIDTH = 14;
+const OPTION_MODEL_WIDTH = 26;
+const OPTION_CTX_WIDTH = 5;
+
+const { stripVTControlCharacters } = await import("node:util");
+
+function optionPad(text, color, width) {
+  const visible = stripVTControlCharacters(String(text)).length;
+  const padded = String(text).padEnd(width);
+  return color ? color(padded.slice(0, padded.length - Math.max(0, visible - width))) : padded;
+}
+
+function optionStatusTag(kind) {
+  const statuses = {
+    running: ["RUNNING", pc.green],
+    ready: ["READY", pc.green],
+    missing: ["MISSING", pc.red],
+    setup: ["SETUP", pc.yellow],
+  };
+  const [text, color] = statuses[kind] ?? [kind, pc.dim];
+  return optionPad(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 optionPad(label, colors[sourceId] ?? pc.dim, OPTION_SOURCE_WIDTH);
+}
+
+function optionCtxLabel(item) {
+  if (item.type === "profile" && item.profile.flags?.ctxSize) {
+    return `${(item.profile.flags.ctxSize / 1000).toFixed(0)}k`;
+  }
+  return "—";
+}
+
+function optionSizeLabel(item) {
+  if (item.type === "profile") {
+    if (item.fileMissing) return "—";
+    if (item.profile.modelPath && existsSync(item.profile.modelPath)) {
+      return formatBytes(statSync(item.profile.modelPath).size);
+    }
+    return "—";
+  }
+  if (item.type === "new") {
+    return formatBytes(item.model.sizeBytes);
+  }
+  // managed
+  if (item.model.quant) return item.model.quant;
+  if (item.model.sizeBytes) return formatBytes(item.model.sizeBytes);
+  return "—";
+}
+
+function optionLabel({ status, source, name, ctx, size }) {
+  return [status, source, pc.bold(optionPad(name, null, OPTION_MODEL_WIDTH)), ctx, pc.dim(size)].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,
+        ctx: optionCtxLabel(item),
+        size: optionSizeLabel(item),
+      }),
+    };
+  }
+  if (item.type === "new") {
+    return {
+      value: itemKey(item),
+      label: optionLabel({
+        status: optionStatusTag("setup"),
+        source: optionSourceTag("gguf", "GGUF file"),
+        name: item.model.label,
+        ctx: optionCtxLabel(item),
+        size: optionSizeLabel(item),
+      }),
+    };
+  }
+  const backend = BACKENDS[item.backendId];
+  return {
+    value: itemKey(item),
+    label: optionLabel({
+      status: optionStatusTag("setup"),
+      source: optionSourceTag(item.backendId, backend.label),
+      name: item.model.label,
+      ctx: optionCtxLabel(item),
+      size: optionSizeLabel(item),
+    }),
+  };
+}
+
+export function printWorkspaceHeader(normalized, runningProfilesNow) {
+  const profiles = normalized.profiles;
+  const readyCount = profiles.filter((p) => !isProfileFileMissing(p) && !runningProfilesNow.some((r) => r.id === p.id)).length;
+  const runningCount = runningProfilesNow.length;
+  const missingCount = profiles.filter((p) => isProfileFileMissing(p)).length;
+  const setupCount = normalized.newModels.length + normalized.managedItems.length;
+
+  const countParts = [];
+  if (readyCount > 0) countParts.push(`${readyCount} ready`);
+  if (runningCount > 0) countParts.push(`${runningCount} running`);
+  if (missingCount > 0) countParts.push(`${missingCount} missing`);
+  if (setupCount > 0) countParts.push(`${setupCount} need setup`);
+
+  console.log(pc.bold("  offgrid-ai"));
+  console.log(pc.dim(`   ${countParts.join(" · ")} · ${DATA_DIR}`));
+}
+
+export async function printBenchmarkLine() {
+  const repoPath = await findBenchmarkRepo();
+  if (repoPath) {
+    console.log(pc.green("   ✓") + " local-llm-visual-benchmark linked");
+  } else {
+    console.log(pc.yellow("   ○") + " to run benchmarks, pair with " + pc.cyan("local-llm-visual-benchmark"));
+  }
+}
+
+function tableWidth() {
+  const header = [
+    optionPad("Status", null, OPTION_STATUS_WIDTH),
+    optionPad("Backend", null, OPTION_SOURCE_WIDTH),
+    optionPad("Model", null, OPTION_MODEL_WIDTH),
+    optionPad("Ctx", null, OPTION_CTX_WIDTH),
+    "Size",
+  ].join("  \u2502  ");
+  return stripVTControlCharacters(header).length;
+}
+
+export function printTableHeader() {
+  console.log("");
+  const header = [
+    optionPad("Status", pc.dim, OPTION_STATUS_WIDTH),
+    optionPad("Backend", pc.dim, OPTION_SOURCE_WIDTH),
+    optionPad("Model", pc.dim, OPTION_MODEL_WIDTH),
+    optionPad("Ctx", pc.dim, OPTION_CTX_WIDTH),
+    pc.dim("Size"),
+  ].join(OPTION_SEPARATOR);
+  console.log(header);
+  console.log(pc.dim("─".repeat(tableWidth())));
+}
+
+export function printTableFooter() {
+  console.log(pc.dim("─".repeat(tableWidth())));
+}
+
+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

@@ -64,7 +64,7 @@ export async function configureLocalProfile(prompt, profile) {
     ["Sampling", samplingSummary(profile.flags)],
   ])));
   console.log(pc.dim("Larger context windows use more memory. KV cache precision controls memory used by attention history."));
-  console.log(pc.dim("Sampling defaults are shown for transparency; you can edit command.json later if needed.\n"));
+  console.log(pc.dim("Sampling defaults are shown for transparency; you can edit the profile later if needed.\n"));
 
   if (caps.mtp) {
     const drafterInfo = configured.drafterPath ? `\n  Drafter: ${configured.drafterPath}` : "";
@@ -137,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) {
-    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/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);
+}