ollanet 0.6.2 → 0.6.4

package/dist/bench-suite.js

@@ -2,6 +2,8 @@
  * Built-in ollanet bench suites, checkers, and revision hashes.
  */
 import { createHash } from "node:crypto";
+/** Pinned length for `full`'s prose throughput case (`throughput_long`). */
+export const LONG_THROUGHPUT_NUM_PREDICT = 1024;
 const MATH_ANSWER = 323;
 const REASON_ANSWER = 42;
 function lastTokenNormalized(content) {
@@ -104,18 +106,23 @@ const FULL_EXTRA = [
     {
         id: "reason",
         role: "check",
-        prompt: "A box has 10 apples. You eat 3, then buy 5 more, then give away 2 times as many as you ate. " +
-            "How many apples are left? Reply with only the final number.",
+        prompt: "Start with 40. Add 7. Subtract 5. Reply with only the final number.",
         num_predict: 48,
-        // 10 - 3 + 5 - 6 = 6... wait: gave away 2*3=6, so 10-3+5-6=6. Spec said 42 as placeholder.
-        // Use a problem that clearly ends at 42:
-        // Actually rewrite for 42: "Start with 40. Add 7. Subtract 5. Reply with only the number." => 42
         check: checkExpectedInt(REASON_ANSWER),
     },
+    {
+        id: "throughput_long",
+        role: "throughput",
+        // Chat-shaped tokens (markdown, lists, a table) at a long pin. Anti-EOS
+        // so done_reason=length; one shot (not --runs) so full stays usable.
+        prompt: "Write a detailed trade-off briefing for a product team choosing a web UI stack. " +
+            "Compare at least two options. Use markdown headings, bullet lists, and at least one table. " +
+            "Keep adding sections (testing, hiring, migration, failure modes, cost) without wrapping up. " +
+            "Do not write a closing recommendation that ends the piece. Do not stop early.",
+        num_predict: LONG_THROUGHPUT_NUM_PREDICT,
+        repeats: 1,
+    },
 ];
-// Fix reason prompt to match REASON_ANSWER
-FULL_EXTRA[FULL_EXTRA.length - 1].prompt =
-    "Start with 40. Add 7. Subtract 5. Reply with only the final number.";
 export function getSuiteCases(suite) {
     if (suite === "full")
         return [...QUICK_CASES, ...FULL_EXTRA];

package/dist/bench.js

@@ -1,8 +1,8 @@
 /**
  * ollanet bench — speed + lightweight quality suite against Ollama models.
  */
-import { defaultModelForHost, loadConfig, machineSettingsForHost, mergeSettings, settingsFromEnv, } from "./config.js";
-import { comparabilityKey, getSuiteCases, median, suiteRevision, } from "./bench-suite.js";
+import { defaultModelForHost, loadConfig, lookupAlias, machineSettingsForHost, mergeSettings, settingsFromEnv, } from "./config.js";
+import { comparabilityKey, getSuiteCases, LONG_THROUGHPUT_NUM_PREDICT, median, suiteRevision, } from "./bench-suite.js";
 import { benchmarksDir, newBenchId, saveBenchmark } from "./bench-store.js";
 import { readFile } from "node:fs/promises";
 import { envInt, ollamaBaseUrl, shortName } from "./hosts.js";
@@ -23,19 +23,20 @@ Examples:
   ollanet bench studio gemma3:12b --hot --runs 5
   ollanet help bench
 
-Fixed suite (not compare). Checks run once; throughput repeats --runs times.
+Fixed suite (not compare). Checks run once; 256-token throughput repeats --runs times.
 Median tok/s excludes early-stops. Unload is between models, not between repeats.
+full adds json/reason checks plus one 1024-token prose generation (tok/s long).
 
 Options:
   --all                 Every completion-capable model from /api/tags
   --exclude-vision      With --all, skip models that advertise vision
   --suite quick|full    Prompt suite (default quick)
-  --runs <n>            Counted throughput repeats (default 3)
-  --hot                 Discard first throughput run; keep models loaded
+  --runs <n>            Counted 256-token throughput repeats (default 3)
+  --hot                 Discard first 256-token throughput run; keep models loaded
   --warmup              Short discarded call before timed cases (default on)
   --no-warmup           Skip the short warmup (--hot implies this)
   --cold-load           Measure cold load via unload + /api/ps
-  --num-predict <n>     Pin throughput length (default 256)
+  --num-predict <n>     Pin 256-token throughput length (default 256; not the long case)
   --num-ctx <n>         Context window override
   --keep-alive <value>  Keep model loaded (e.g. 5m, 0, -1)
   --think / --no-think  Thinking tokens (default off)
@@ -65,6 +66,26 @@ function resolveModelName(tags, query) {
     const prefix = tags.find((t) => t.name.toLowerCase().startsWith(`${q}:`) || q.startsWith(`${t.name.toLowerCase()}:`));
     return prefix?.name;
 }
+function pinnedNumPredict(caseDef, throughputNumPredict) {
+    if (caseDef.role === "throughput") {
+        return caseDef.num_predict ?? throughputNumPredict;
+    }
+    return caseDef.num_predict ?? 32;
+}
+/** At least the global timeout; longer pins need room to finish at ~8 tok/s. */
+function attemptTimeoutMs(numPredict) {
+    return Math.max(BENCH_TIMEOUT_MS, Math.ceil(numPredict / 8) * 1000);
+}
+function caseReps(caseDef, runs, hot) {
+    if (caseDef.role !== "throughput")
+        return 1;
+    if (caseDef.repeats != null)
+        return caseDef.repeats;
+    return runs + (hot ? 1 : 0);
+}
+function discardFirstThroughput(caseDef, hot) {
+    return hot && caseDef.role === "throughput" && caseDef.repeats == null;
+}
 function tokPerSec(chunk) {
     if (chunk.eval_count == null || chunk.eval_duration == null || chunk.eval_duration <= 0) {
         return undefined;
@@ -285,9 +306,7 @@ async function runColdLoad(baseUrl, model, keepAlive) {
     }
 }
 async function runCaseAttempt(opts) {
-    const numPredict = opts.caseDef.role === "throughput"
-        ? opts.throughputNumPredict
-        : (opts.caseDef.num_predict ?? 32);
+    const numPredict = pinnedNumPredict(opts.caseDef, opts.throughputNumPredict);
     const settings = mergeSettings(opts.settings, {
         temperature: 0,
         seed: 0,
@@ -303,7 +322,7 @@ async function runCaseAttempt(opts) {
             messages: [{ role: "user", content: opts.caseDef.prompt }],
             stream: false,
             writeStdout: false,
-            timeoutMs: BENCH_TIMEOUT_MS,
+            timeoutMs: attemptTimeoutMs(numPredict),
             settings,
         });
         const wallMs = Date.now() - wall0;
@@ -373,12 +392,23 @@ async function runCaseAttempt(opts) {
 function countedAttempts(attempts) {
     return attempts.filter((a) => !a.discarded);
 }
-function summarizeModel(cases, cold, selfJudge) {
-    const throughput = cases.find((c) => c.id === "throughput");
-    const counted = countedAttempts(throughput?.attempts ?? []);
+function speedFrom(cases, id) {
+    const counted = countedAttempts(cases.find((c) => c.id === id)?.attempts ?? []);
     const fullLen = counted.filter((a) => !a.error && !a.early_stop && a.tok_s != null);
     const toks = fullLen.map((a) => a.tok_s);
-    const earlyStopCount = counted.filter((a) => a.early_stop || (a.done_reason && a.done_reason !== "length")).length;
+    return {
+        median: median(toks) ?? null,
+        min: toks.length ? Math.min(...toks) : null,
+        max: toks.length ? Math.max(...toks) : null,
+    };
+}
+function summarizeModel(cases, cold, selfJudge) {
+    const peak = speedFrom(cases, "throughput");
+    const long = speedFrom(cases, "throughput_long");
+    const throughputAttempts = cases
+        .filter((c) => c.role === "throughput")
+        .flatMap((c) => countedAttempts(c.attempts));
+    const earlyStopCount = throughputAttempts.filter((a) => a.early_stop || (a.done_reason && a.done_reason !== "length")).length;
     const checkAttempts = cases
         .filter((c) => c.role === "check")
         .flatMap((c) => c.attempts)
@@ -386,9 +416,12 @@ function summarizeModel(cases, cold, selfJudge) {
     const passed = checkAttempts.filter((a) => a.quality?.pass).length;
     const passRate = checkAttempts.length > 0 ? passed / checkAttempts.length : null;
     return {
-        tok_s_median: median(toks) ?? null,
-        tok_s_min: toks.length ? Math.min(...toks) : null,
-        tok_s_max: toks.length ? Math.max(...toks) : null,
+        tok_s_median: peak.median,
+        tok_s_min: peak.min,
+        tok_s_max: peak.max,
+        tok_s_long_median: long.median,
+        tok_s_long_min: long.min,
+        tok_s_long_max: long.max,
         early_stop_count: earlyStopCount,
         pass_rate: passRate,
         load_ms: cold && cold.error == null && cold.load_ms > 0 ? cold.load_ms : cold?.error ? null : cold?.load_ms ?? null,
@@ -404,17 +437,22 @@ function printTable(machine, suite, runs, revision, compKey, models, skipped, co
         lines.push("Cold-load: on");
     if (hot)
         lines.push("Hot: first throughput run discarded; models stay loaded");
+    if (suite === "full")
+        lines.push("full: tok/s long is one 1024-token prose generation");
     lines.push("");
+    const showLong = suite === "full";
     const header = coldLoad
         ? pad("Model", MODEL_COL) +
             pad("tok/s (med)", 12) +
             pad("spread", 12) +
+            (showLong ? pad("tok/s long", 12) : "") +
             pad("load", 8) +
             pad("pass", 8) +
             "notes"
         : pad("Model", MODEL_COL) +
             pad("tok/s (med)", 12) +
             pad("spread", 12) +
+            (showLong ? pad("tok/s long", 12) : "") +
             pad("pass", 8) +
             "notes";
     lines.push(header);
@@ -448,6 +486,7 @@ function printTable(machine, suite, runs, revision, compKey, models, skipped, co
         const spread = m.summary.tok_s_min != null && m.summary.tok_s_max != null
             ? `${m.summary.tok_s_min.toFixed(1)}–${m.summary.tok_s_max.toFixed(1)}`
             : "—";
+        const tokLong = m.summary.tok_s_long_median != null ? m.summary.tok_s_long_median.toFixed(1) : "—";
         const pass = m.summary.pass_rate != null
             ? `${Math.round(m.summary.pass_rate * checkDenom(m))}/${checkDenom(m)}`
             : "—";
@@ -467,12 +506,14 @@ function printTable(machine, suite, runs, revision, compKey, models, skipped, co
             ? pad(m.name, MODEL_COL) +
                 pad(tok, 12) +
                 pad(spread, 12) +
+                (showLong ? pad(tokLong, 12) : "") +
                 pad(load, 8) +
                 pad(pass, 8) +
                 notes.join("; ")
             : pad(m.name, MODEL_COL) +
                 pad(tok, 12) +
                 pad(spread, 12) +
+                (showLong ? pad(tokLong, 12) : "") +
                 pad(pass, 8) +
                 notes.join("; ");
         lines.push(row);
@@ -501,7 +542,16 @@ function pad(s, n) {
 export async function main() {
     const parsed = parseArgs(process.argv.slice(2));
     const config = await loadConfig();
-    const host = await resolveTarget(parsed.machine, config);
+    const alias = lookupAlias(config, parsed.machine);
+    let machineQuery = parsed.machine;
+    let models = [...parsed.models];
+    if (alias) {
+        machineQuery = alias.machine;
+        if (models.length === 0 && !parsed.all) {
+            models = [alias.model];
+        }
+    }
+    const host = await resolveTarget(machineQuery, config);
     const baseUrl = ollamaBaseUrl(host);
     const machineLabel = shortName(host);
     const tags = await ollamaTags(baseUrl, Math.min(BENCH_TIMEOUT_MS, 15_000));
@@ -528,8 +578,8 @@ export async function main() {
             selected.push(t.name);
         }
     }
-    else if (parsed.models.length > 0) {
-        for (const q of parsed.models) {
+    else if (models.length > 0) {
+        for (const q of models) {
             const resolved = resolveModelName(tags, q);
             if (!resolved) {
                 console.error(`Unknown model "${q}". Available: ${tagNames.join(", ")}`);
@@ -546,7 +596,7 @@ export async function main() {
     else {
         const def = defaultModelForHost(config, host);
         if (!def) {
-            console.error(`No model specified for "${machineLabel}". Pass model names, use --all, or set defaultModels.`);
+            console.error(`No model specified for "${machineLabel}". Pass model names, use --all, set defaultModels, or use an alias.`);
             process.exit(1);
         }
         const name = resolveModelName(tags, def);
@@ -585,10 +635,13 @@ export async function main() {
         hot: parsed.hot,
     });
     const suiteCases = getSuiteCases(parsed.suite);
-    const throughputReps = parsed.runs + (parsed.hot ? 1 : 0);
     const caseCount = selected.length *
-        (suiteCases.filter((c) => c.role !== "throughput").length +
-            suiteCases.filter((c) => c.role === "throughput").length * throughputReps);
+        suiteCases.reduce((n, c) => n + caseReps(c, parsed.runs, parsed.hot), 0);
+    const worstCaseMs = selected.length *
+        suiteCases.reduce((n, c) => {
+            const pin = pinnedNumPredict(c, parsed.throughputNumPredict);
+            return n + caseReps(c, parsed.runs, parsed.hot) * attemptTimeoutMs(pin);
+        }, 0);
     if (!parsed.json) {
         const skipBits = [
             skipped.filter((s) => s.reason === "non-completion").length
@@ -603,7 +656,10 @@ export async function main() {
             ` × suite=${parsed.suite} × runs=${parsed.runs}` +
             (parsed.hot ? " (hot: +1 discarded)" : ""));
         console.error(`Cases: ~${caseCount} chat calls   timeout: ${BENCH_TIMEOUT_MS}ms/case` +
-            `   worst-case ceiling: ~${Math.ceil((caseCount * BENCH_TIMEOUT_MS) / 60000)}m if every call times out`);
+            (parsed.suite === "full"
+                ? ` (long case ≥${attemptTimeoutMs(LONG_THROUGHPUT_NUM_PREDICT)}ms)`
+                : "") +
+            `   worst-case ceiling: ~${Math.ceil(worstCaseMs / 60000)}m if every call times out`);
         if (!parsed.hot && !isLoopback(host) && (selected.length >= 2 || parsed.coldLoad)) {
             const bits = [
                 selected.length >= 2 ? "unloads each model before the next" : "",
@@ -665,8 +721,8 @@ export async function main() {
         let modelError;
         for (const caseDef of suiteCases) {
             const attempts = [];
-            const discardFirst = parsed.hot && caseDef.role === "throughput";
-            const reps = caseDef.role === "throughput" ? parsed.runs + (discardFirst ? 1 : 0) : 1;
+            const discardFirst = discardFirstThroughput(caseDef, parsed.hot);
+            const reps = caseReps(caseDef, parsed.runs, parsed.hot);
             for (let i = 0; i < reps; i += 1) {
                 const discarded = discardFirst && i === 0;
                 const attempt = await runCaseAttempt({
@@ -758,6 +814,7 @@ export async function main() {
             temperature: 0,
             seed: 0,
             throughput_num_predict: parsed.throughputNumPredict,
+            throughput_long_num_predict: parsed.suite === "full" ? LONG_THROUGHPUT_NUM_PREDICT : null,
             num_ctx: baseSettings.num_ctx ?? null,
             warmup: parsed.warmup,
             hot: parsed.hot,

package/dist/cli.d.ts

@@ -1,13 +1,16 @@
 #!/usr/bin/env node
 /**
- * ollanet — chat with Ollama servers on any reachable network.
+ * ollanet — Ollama over any reachable network (CLI, MCP, library).
  *
  *   ollanet scan
  *   ollanet prompt <machine-or-ip> "hello"
+ *   ollanet compare <machine> <model> <model>
  *   ollanet pull <machine> <model>
  *   ollanet show <machine> <model>
  *   ollanet rm <machine> <model> --yes
  *   ollanet ps [machine]
+ *   ollanet bench <machine> [model...]
  *   ollanet chats
+ *   ollanet mcp
  */
 export {};

package/dist/cli.js

@@ -1,19 +1,22 @@
 #!/usr/bin/env node
 /**
- * ollanet — chat with Ollama servers on any reachable network.
+ * ollanet — Ollama over any reachable network (CLI, MCP, library).
  *
  *   ollanet scan
  *   ollanet prompt <machine-or-ip> "hello"
+ *   ollanet compare <machine> <model> <model>
  *   ollanet pull <machine> <model>
  *   ollanet show <machine> <model>
  *   ollanet rm <machine> <model> --yes
  *   ollanet ps [machine]
+ *   ollanet bench <machine> [model...]
  *   ollanet chats
+ *   ollanet mcp
  */
 const HELP = `ollanet — Ollama over your network
 
-Discover Ollama hosts on localhost, your LAN, Tailscale, or any IP/hostname
-you can reach — then chat with hash-addressed transcripts.
+Discover hosts, manage models, prompt and compare, bench tok/s, and continue
+chats by hash. CLI, MCP, and a Node library — same mesh.
 
 Usage:
   ollanet scan [--json] [--all] [--lan] [--last]
@@ -27,6 +30,7 @@ Usage:
   ollanet ps [machine]
   ollanet chats [--json] [--id <hash>]
   ollanet bench <machine|ip> [model...] [--all] [options]
+  ollanet alias list|add|rm …
   ollanet mcp
   ollanet help [command]
 
@@ -44,6 +48,8 @@ Examples:
   ollanet rm studio llama3.2:1b --yes
   ollanet ps studio
   ollanet chats
+  ollanet alias add desk studio gemma3:12b
+  ollanet prompt desk "hello"  # expands machine + model
   ollanet bench localhost --all
   ollanet bench localhost llama3.2:1b --runs 3
   ollanet bench localhost gemma3:12b --hot --runs 5
@@ -53,6 +59,7 @@ Examples:
 Config: ~/.ollanet/config.json when installed, ./config.json in a checkout
         (override with OLLANET_CONFIG)
 Hosts:  config.hosts, OLLANET_HOSTS, optional Tailscale + --lan
+Aliases: config.aliases — ollanet alias add|list|rm
 Chats:  ~/.ollanet/responses or ./responses (override with OLLANET_RESPONSES_DIR)
 Scan:   ~/.ollanet/last-scan.json or ./last-scan.json (override with OLLANET_LAST_SCAN)
 `;
@@ -162,6 +169,12 @@ async function main() {
             await run();
             return;
         }
+        case "alias":
+        case "aliases": {
+            const { main: run } = await import("./alias.js");
+            await run();
+            return;
+        }
         default:
             console.error(`Unknown command: ${cmd}\n`);
             process.stderr.write(HELP);

package/dist/compare.js

@@ -4,7 +4,7 @@
  *   ollanet compare studio gemma3:12b llama3.2:3b --prompt "Explain MagicDNS"
  *   ollanet compare studio m1 m2 --file task.md
  */
-import { configFromPartial, loadConfig, machineSettingsForHost, mergeSettings, settingsFromEnv, } from "./config.js";
+import { configFromPartial, loadConfig, lookupAlias, machineSettingsForHost, mergeSettings, settingsFromEnv, } from "./config.js";
 import { envInt, ollamaBaseUrl, shortName } from "./hosts.js";
 import { consumeSettingsFlag, failUsage, isHelpFlag, printHelp, takeFlag, takeValue } from "./argv.js";
 import { resolveTarget } from "./target.js";
@@ -244,6 +244,14 @@ export async function main() {
         console.error("Machine is required.");
         usage();
     }
+    const config = await loadConfig();
+    const alias = lookupAlias(config, parsed.machine);
+    const machine = alias ? alias.machine : parsed.machine;
+    let models = [...parsed.models];
+    if (alias && models.length === 1) {
+        // `compare desk other:7b` → alias model vs other on alias host
+        models = [alias.model, models[0]];
+    }
     const { stdin: stdinStream } = await import("node:process");
     let fromStdin = "";
     if (!stdinStream.isTTY) {
@@ -265,14 +273,15 @@ export async function main() {
     }
     const prompt = assemblePrompt({ argv: parsed.prompt, file: fileText, stdin: fromStdin });
     const record = await runCompare({
-        machine: parsed.machine,
-        models: parsed.models,
+        machine,
+        models,
         prompt: prompt || undefined,
         settings: parsed.settings,
         save: parsed.save,
         unload: parsed.unload,
         writeStdout: !parsed.json,
         quiet: parsed.json,
+        config,
     });
     if (record.default_prompt) {
         process.stderr.write("Using default compare prompt (pass --prompt or --file to override).\n");

package/dist/config.d.ts

@@ -17,6 +17,11 @@ export interface GenerateSettings {
      */
     think?: boolean;
 }
+/** Named shortcut for a frequent machine + model pair. */
+export interface ModelAlias {
+    machine: string;
+    model: string;
+}
 export interface AppConfig {
     /** Explicit hosts/IPs to probe (LAN, VPN, MagicDNS, etc.). */
     hosts: HostConfigEntry[];
@@ -28,10 +33,28 @@ export interface AppConfig {
     machineDefaults: Record<string, GenerateSettings & {
         model?: string;
     }>;
+    /** Shortcuts: `ollanet prompt <alias> "…"` expands to machine + model. */
+    aliases: Record<string, ModelAlias>;
 }
 /** Build an AppConfig from an in-memory partial (no file I/O). */
 export declare function configFromPartial(partial?: Partial<AppConfig>): AppConfig;
 export declare function loadConfig(): Promise<AppConfig>;
+/**
+ * Read-modify-write the config JSON on disk. Preserves unknown keys.
+ * Creates the parent directory when missing (installed `~/.ollanet/`).
+ */
+export declare function mutateConfigFile(mutate: (file: Record<string, unknown>) => void): Promise<void>;
+/** Alias names: letter start, then letters/digits/_/- (no colons — those look like models). */
+export declare function isValidAliasName(name: string): boolean;
+export declare function lookupAlias(config: AppConfig, name: string | undefined): ModelAlias | undefined;
+/**
+ * If `machine` is an alias name, expand to that alias's host.
+ * When `model` is omitted, fill it from the alias too.
+ */
+export declare function expandMachineModel(config: AppConfig, machine: string | undefined, model: string | undefined): {
+    machine?: string;
+    model?: string;
+};
 export declare function normalizeSettings(input: unknown): GenerateSettings;
 export declare function parseFormat(value: unknown): GenerateSettings["format"] | undefined;
 export declare function hostLookupKeys(host: HostTarget): string[];

package/dist/config.js

@@ -1,4 +1,5 @@
-import { readFile } from "node:fs/promises";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
 import { shortName, } from "./hosts.js";
 import { defaultConfigPath } from "./paths.js";
 function emptyConfig() {
@@ -8,6 +9,7 @@ function emptyConfig() {
         defaultModels: {},
         defaults: {},
         machineDefaults: {},
+        aliases: {},
     };
 }
 /** Build an AppConfig from an in-memory partial (no file I/O). */
@@ -19,6 +21,7 @@ export function configFromPartial(partial = {}) {
         defaultModels: partial.defaultModels ?? empty.defaultModels,
         defaults: partial.defaults ?? empty.defaults,
         machineDefaults: partial.machineDefaults ?? empty.machineDefaults,
+        aliases: partial.aliases ?? empty.aliases,
     };
 }
 const CONFIG_PATH = process.env.OLLANET_CONFIG ??
@@ -42,6 +45,7 @@ export async function loadConfig() {
             defaultModels,
             defaults: normalizeSettings(parsed.defaults),
             machineDefaults,
+            aliases: normalizeAliases(parsed.aliases),
         };
     }
     catch (err) {
@@ -52,6 +56,29 @@ export async function loadConfig() {
         throw new Error(`Failed to read config at ${CONFIG_PATH}: ${err instanceof Error ? err.message : err}`);
     }
 }
+/**
+ * Read-modify-write the config JSON on disk. Preserves unknown keys.
+ * Creates the parent directory when missing (installed `~/.ollanet/`).
+ */
+export async function mutateConfigFile(mutate) {
+    let file = {};
+    try {
+        const raw = await readFile(CONFIG_PATH, "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            file = parsed;
+        }
+    }
+    catch (err) {
+        const code = err.code;
+        if (code !== "ENOENT") {
+            throw new Error(`Failed to read config at ${CONFIG_PATH}: ${err instanceof Error ? err.message : err}`);
+        }
+    }
+    mutate(file);
+    await mkdir(path.dirname(CONFIG_PATH), { recursive: true });
+    await writeFile(CONFIG_PATH, `${JSON.stringify(file, null, 2)}\n`, "utf8");
+}
 function normalizeDiscovery(input) {
     if (!input || typeof input !== "object")
         return {};
@@ -77,6 +104,51 @@ function normalizeStringMap(map) {
     }
     return out;
 }
+function normalizeAliases(map) {
+    if (!map || typeof map !== "object" || Array.isArray(map))
+        return {};
+    const out = {};
+    for (const [key, value] of Object.entries(map)) {
+        const name = key.trim().toLowerCase();
+        if (!name || !value || typeof value !== "object" || Array.isArray(value))
+            continue;
+        const row = value;
+        const machine = typeof row.machine === "string" ? row.machine.trim() : "";
+        const model = typeof row.model === "string" ? row.model.trim() : "";
+        if (!machine || !model)
+            continue;
+        out[name] = { machine, model };
+    }
+    return out;
+}
+/** Alias names: letter start, then letters/digits/_/- (no colons — those look like models). */
+export function isValidAliasName(name) {
+    return /^[a-z][a-z0-9_-]*$/i.test(name.trim());
+}
+export function lookupAlias(config, name) {
+    if (!name?.trim())
+        return undefined;
+    return config.aliases[name.trim().toLowerCase()];
+}
+/**
+ * If `machine` is an alias name, expand to that alias's host.
+ * When `model` is omitted, fill it from the alias too.
+ */
+export function expandMachineModel(config, machine, model) {
+    if (!machine?.trim())
+        return { machine, model };
+    const alias = lookupAlias(config, machine);
+    if (!alias) {
+        return {
+            machine: machine.trim(),
+            model: model?.trim() ? model.trim() : undefined,
+        };
+    }
+    return {
+        machine: alias.machine,
+        model: model?.trim() ? model.trim() : alias.model,
+    };
+}
 function normalizeMachineDefaults(map) {
     const out = {};
     for (const [key, value] of Object.entries(map ?? {})) {

package/dist/help.js

@@ -11,6 +11,7 @@ const LOADERS = {
     ps: () => import("./ps.js"),
     compare: () => import("./compare.js"),
     bench: () => import("./bench.js"),
+    alias: () => import("./alias.js"),
     mcp: () => import("./mcp.js"),
 };
 const ALIASES = {
@@ -26,6 +27,7 @@ const ALIASES = {
     vs: "compare",
     h2h: "compare",
     benchmark: "bench",
+    aliases: "alias",
 };
 export function canonicalCommand(name) {
     const key = name.trim().toLowerCase();

package/dist/index.d.ts

@@ -13,8 +13,8 @@ export { lastScan, lastScanPath, loadLastScan } from "./scan-store.js";
 export type { StoredScan } from "./scan-store.js";
 export { discoverHosts, resolveHost, ollamaBaseUrl, shortName, ollamaPort, } from "./hosts.js";
 export type { DiscoverOptions, DiscoveryResult, HostTarget, HostSource, HostConfigEntry, } from "./hosts.js";
-export { loadConfig, defaultModelForHost, mergeSettings, configFromPartial, } from "./config.js";
-export type { AppConfig, DiscoveryConfig, GenerateSettings } from "./config.js";
+export { loadConfig, defaultModelForHost, mergeSettings, configFromPartial, lookupAlias, expandMachineModel, } from "./config.js";
+export type { AppConfig, DiscoveryConfig, GenerateSettings, ModelAlias } from "./config.js";
 export { runPrompt } from "./prompt.js";
 export type { PromptRunOptions, PromptRunResult } from "./prompt.js";
 export { runCompare, DEFAULT_COMPARE_PROMPT } from "./compare.js";

package/dist/index.js

@@ -10,7 +10,7 @@
 export { scanNetwork } from "./scan.js";
 export { lastScan, lastScanPath, loadLastScan } from "./scan-store.js";
 export { discoverHosts, resolveHost, ollamaBaseUrl, shortName, ollamaPort, } from "./hosts.js";
-export { loadConfig, defaultModelForHost, mergeSettings, configFromPartial, } from "./config.js";
+export { loadConfig, defaultModelForHost, mergeSettings, configFromPartial, lookupAlias, expandMachineModel, } from "./config.js";
 export { runPrompt } from "./prompt.js";
 export { runCompare, DEFAULT_COMPARE_PROMPT } from "./compare.js";
 export { assemblePrompt, readPromptFile } from "./prompt-input.js";

package/dist/mcp.d.ts

@@ -2,7 +2,8 @@
  * ollanet mcp — stdio MCP server (zero deps).
  *
  * Speaks the Model Context Protocol over stdin/stdout so agents (Cursor,
- * Claude Desktop, etc.) can discover hosts, prompt models, and continue chats.
+ * Claude Desktop, etc.) can discover hosts, manage models, prompt, compare,
+ * and continue chats.
  *
  *   ollanet mcp
  *

package/dist/mcp.js

@@ -2,7 +2,8 @@
  * ollanet mcp — stdio MCP server (zero deps).
  *
  * Speaks the Model Context Protocol over stdin/stdout so agents (Cursor,
- * Claude Desktop, etc.) can discover hosts, prompt models, and continue chats.
+ * Claude Desktop, etc.) can discover hosts, manage models, prompt, compare,
+ * and continue chats.
  *
  *   ollanet mcp
  *
@@ -200,7 +201,7 @@ const TOOLS = [
     {
         name: "ollanet_ps",
         description: "List models currently loaded in VRAM. Optional machine; omit to probe every discovered host. " +
-            "scan is on-disk inventory; ps is what is resident right now.",
+            "scan is on-disk inventory; ps is what is resident right now, with CPU/GPU %.",
         inputSchema: {
             type: "object",
             properties: {

package/dist/ollama-chat.d.ts

@@ -74,6 +74,8 @@ export declare function ollamaVersion(baseUrl: string, timeoutMs: number): Promi
 export interface PsModel {
     name?: string;
     model?: string;
+    /** Total resident bytes (VRAM + CPU/RAM). */
+    size?: number;
     size_vram?: number;
     context_length?: number;
     digest?: string;