ollanet 0.1.0 → 0.2.0

package/dist/cli.js

@@ -16,6 +16,7 @@ Usage:
   ollanet prompt <machine|ip> [model] <prompt...>
   ollanet prompt --chat <hash> <prompt...>
   ollanet chats [--json] [--id <hash>]
+  ollanet bench <machine|ip> [model...] [--all] [options]
 
 Examples:
   ollanet scan
@@ -24,6 +25,8 @@ Examples:
   ollanet prompt 192.168.1.50 gemma4:12b "Hello"
   ollanet prompt --chat a1b2c3d4e5f6 "Tell me more"
   ollanet chats
+  ollanet bench localhost --all
+  ollanet bench localhost llama3.2:1b --runs 3
 
 Config: ~/.ollanet/config.json when installed, ./config.json in a checkout
         (override with OLLANET_CONFIG)
@@ -68,6 +71,12 @@ async function main() {
             await run();
             return;
         }
+        case "bench":
+        case "benchmark": {
+            const { main: run } = await import("./bench.js");
+            await run();
+            return;
+        }
         default:
             console.error(`Unknown command: ${cmd}\n`);
             process.stderr.write(HELP);

package/dist/config.js

@@ -94,6 +94,9 @@ export function normalizeSettings(input) {
     const numCtx = asFiniteNumber(src.num_ctx ?? src.numCtx);
     if (numCtx != null)
         out.num_ctx = Math.trunc(numCtx);
+    const seed = asFiniteNumber(src.seed);
+    if (seed != null)
+        out.seed = Math.trunc(seed);
     const keepAlive = src.keep_alive ?? src.keepAlive;
     if (typeof keepAlive === "string" && keepAlive.trim()) {
         out.keep_alive = keepAlive.trim();
@@ -107,6 +110,16 @@ export function normalizeSettings(input) {
     if (typeof src.system === "string" && src.system.trim()) {
         out.system = src.system;
     }
+    const think = src.think;
+    if (typeof think === "boolean")
+        out.think = think;
+    else if (typeof think === "string") {
+        const v = think.trim().toLowerCase();
+        if (["1", "true", "yes", "on"].includes(v))
+            out.think = true;
+        if (["0", "false", "no", "off"].includes(v))
+            out.think = false;
+    }
     return out;
 }
 function asFiniteNumber(value) {
@@ -186,12 +199,16 @@ export function mergeSettings(...layers) {
             out.num_predict = layer.num_predict;
         if (layer.num_ctx != null)
             out.num_ctx = layer.num_ctx;
+        if (layer.seed != null)
+            out.seed = layer.seed;
         if (layer.keep_alive != null)
             out.keep_alive = layer.keep_alive;
         if (layer.format !== undefined)
             out.format = layer.format;
         if (layer.system != null)
             out.system = layer.system;
+        if (layer.think != null)
+            out.think = layer.think;
     }
     return out;
 }
@@ -203,6 +220,7 @@ export function settingsFromEnv() {
         keep_alive: process.env.OLLAMA_KEEP_ALIVE,
         format: process.env.OLLAMA_FORMAT,
         system: process.env.OLLAMA_SYSTEM,
+        think: process.env.OLLANET_THINK ?? process.env.OLLAMA_THINK,
     });
 }
 export function settingsSummary(settings) {
@@ -218,6 +236,10 @@ export function settingsSummary(settings) {
     if (settings.format !== undefined) {
         parts.push(settings.format === "json" ? "format=json" : "format=<schema>");
     }
+    if (settings.think === true)
+        parts.push("think=on");
+    if (settings.think === false)
+        parts.push("think=off");
     return parts.join(" ");
 }
 export function configPath() {

package/dist/hosts.js

@@ -3,7 +3,18 @@ import net from "node:net";
 import os from "node:os";
 import { promisify } from "node:util";
 const execFileAsync = promisify(execFile);
-export const OLLAMA_PORT = Number(process.env.OLLAMA_PORT ?? 11434);
+/** Parse a required numeric env var; invalid values throw instead of becoming NaN. */
+export function envInt(name, fallback) {
+    const raw = process.env[name];
+    if (raw == null || String(raw).trim() === "")
+        return fallback;
+    const n = Number(raw);
+    if (!Number.isFinite(n)) {
+        throw new Error(`Invalid ${name}="${raw}" (expected a number)`);
+    }
+    return Math.trunc(n);
+}
+export const OLLAMA_PORT = envInt("OLLAMA_PORT", 11434);
 function cleanDnsName(dnsName) {
     if (!dnsName)
         return "";
@@ -97,7 +108,9 @@ function parseHostEntry(entry) {
     const name = (entry.name ?? address).trim();
     return makeHost({
         hostname: name,
-        dnsName: address.includes(".") ? address : "",
+        // An IPv4 literal is not a DNS name; treating it as one makes shortName()
+        // return the first octet ("192") instead of the configured name.
+        dnsName: !/^\d{1,3}(\.\d{1,3}){3}$/.test(address) && address.includes(".") ? address : "",
         ip: address,
         source: "config",
         online: true,
@@ -242,8 +255,8 @@ async function tcpOpen(ip, port, timeoutMs) {
     });
 }
 async function lanScanTargets(cidrs, port) {
-    const timeoutMs = Number(process.env.OLLANET_LAN_TIMEOUT_MS ?? 200);
-    const concurrency = Number(process.env.OLLANET_LAN_CONCURRENCY ?? 64);
+    const timeoutMs = envInt("OLLANET_LAN_TIMEOUT_MS", 200);
+    const concurrency = Math.max(1, envInt("OLLANET_LAN_CONCURRENCY", 64));
     const ips = [...new Set(cidrs.flatMap((cidr) => cidrToIps(cidr)))];
     if (ips.length === 0)
         return [];
@@ -261,15 +274,21 @@ async function lanScanTargets(cidrs, port) {
         port,
     }));
 }
+/**
+ * True for IPs, FQDNs, and host:port — not bare words.
+ * Bare words must match a discovered host so typos get a helpful error.
+ */
 function looksLikeAddress(query) {
     const q = query.trim();
-    if (!q)
+    if (!q || /\s/.test(q))
         return false;
-    if (/^\d{1,3}(\.\d{1,3}){3}$/.test(q))
+    if (/^\d{1,3}(\.\d{1,3}){3}(:\d+)?$/.test(q))
+        return true;
+    if (/^\[[0-9a-f:]+\](:\d+)?$/i.test(q))
         return true;
-    if (q.includes(":") && !q.includes(" "))
-        return true; // hostname:port or ipv6-ish
-    if (/^[a-z0-9][a-z0-9._-]*$/i.test(q))
+    if (/^[a-z0-9][a-z0-9._-]*:\d+$/i.test(q))
+        return true;
+    if (q.includes(".") && /^[a-z0-9][a-z0-9.-]+$/i.test(q))
         return true;
     return false;
 }
@@ -286,16 +305,23 @@ function parseDirectAddress(query) {
         hostname = ip;
         port = Number(ipv4WithPort[2]);
     }
-    else if (!q.includes("://") && q.includes(".") === false && q.includes(":")) {
-        // host:port without dots (rare) — skip to avoid mangling IPv6
-    }
     else {
+        // host:port with or without dots. Requires a single colon + numeric port so
+        // bare IPv6 (multiple colons) is left alone.
         const hostPort = q.match(/^([a-z0-9][a-z0-9._-]*):(\d+)$/i);
         if (hostPort) {
             hostname = hostPort[1];
             ip = hostname;
             port = Number(hostPort[2]);
         }
+        else {
+            const bracketed = q.match(/^\[([0-9a-f:]+)\]:(\d+)$/i);
+            if (bracketed) {
+                ip = bracketed[1];
+                hostname = ip;
+                port = Number(bracketed[2]);
+            }
+        }
     }
     return makeHost({
         hostname,
@@ -358,16 +384,30 @@ export async function discoverHosts(opts = {}) {
                 : sources.join("+") || "local");
     return { hosts, sources, networkLabel };
 }
+function hostNameMatches(host, q) {
+    const names = [host.hostname, host.dnsName, shortName(host), host.ip].map((n) => n.toLowerCase());
+    return names.includes(q) || names.some((n) => n.startsWith(`${q}.`));
+}
+/**
+ * Match a query against already-discovered hosts only (no direct-address fallback).
+ * Used when peeling an optional leading hostname before a prompt.
+ */
+export function findDiscoveredHost(targets, query) {
+    const q = query.trim().toLowerCase().replace(/\.$/, "");
+    if (!q)
+        return undefined;
+    const matches = targets.filter((host) => hostNameMatches(host, q));
+    if (matches.length === 1)
+        return matches[0];
+    return undefined;
+}
 /** Resolve a machine name against discovered hosts, or treat it as a direct address. */
 export function resolveHost(targets, query) {
     const q = query.trim().toLowerCase().replace(/\.$/, "");
     if (!q) {
         throw new Error("Machine name is empty.");
     }
-    const matches = targets.filter((host) => {
-        const names = [host.hostname, host.dnsName, shortName(host), host.ip].map((n) => n.toLowerCase());
-        return names.includes(q) || names.some((n) => n.startsWith(`${q}.`));
-    });
+    const matches = targets.filter((host) => hostNameMatches(host, q));
     if (matches.length === 1)
         return matches[0];
     if (matches.length > 1) {

package/dist/ollama-chat.js

@@ -0,0 +1,307 @@
+function buildOptions(settings) {
+    const options = {};
+    if (settings.temperature != null)
+        options.temperature = settings.temperature;
+    if (settings.num_predict != null)
+        options.num_predict = settings.num_predict;
+    if (settings.num_ctx != null)
+        options.num_ctx = settings.num_ctx;
+    if (settings.seed != null)
+        options.seed = settings.seed;
+    return options;
+}
+function parseChunk(url, raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`Non-JSON response from ${url} (is something else on this port?): ${raw.slice(0, 120)}`);
+    }
+}
+/** POST /api/chat with optional streaming and AbortSignal timeout. */
+export async function ollamaChat(opts) {
+    const url = `${opts.baseUrl}/api/chat`;
+    // Default think:false — thinking models otherwise burn num_predict on hidden reasoning.
+    const think = opts.settings.think === true;
+    const body = {
+        model: opts.model,
+        messages: opts.messages,
+        stream: opts.stream,
+        think,
+    };
+    if (opts.settings.keep_alive != null)
+        body.keep_alive = opts.settings.keep_alive;
+    if (opts.settings.format !== undefined)
+        body.format = opts.settings.format;
+    const options = buildOptions(opts.settings);
+    if (Object.keys(options).length > 0)
+        body.options = options;
+    const controller = new AbortController();
+    const timer = opts.timeoutMs > 0 ? setTimeout(() => controller.abort(), opts.timeoutMs) : undefined;
+    let res;
+    try {
+        res = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", Accept: "application/json" },
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+    }
+    catch (err) {
+        if (timer)
+            clearTimeout(timer);
+        const name = err instanceof Error ? err.name : "";
+        if (name === "AbortError") {
+            throw new Error(`Prompt timed out after ${opts.timeoutMs}ms (${url})`);
+        }
+        throw err;
+    }
+    if (!res.ok) {
+        if (timer)
+            clearTimeout(timer);
+        const text = await res.text().catch(() => "");
+        throw new Error(`Ollama HTTP ${res.status} ${res.statusText}${text ? `: ${text}` : ""}`);
+    }
+    try {
+        if (!opts.stream) {
+            const chunk = parseChunk(url, await res.text());
+            if (chunk.error)
+                throw new Error(chunk.error);
+            const content = chunk.message?.content ?? "";
+            const thinking = chunk.message?.thinking ?? "";
+            if (opts.writeStdout) {
+                if (think && thinking) {
+                    process.stderr.write(`${thinking}\n---\n`);
+                }
+                const visible = content || thinking;
+                if (visible)
+                    process.stdout.write(`${visible}\n`);
+            }
+            return { content: content || thinking, thinking, chunk };
+        }
+        if (!res.body)
+            throw new Error("No response body from Ollama");
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        let last = {};
+        let content = "";
+        let thinking = "";
+        let thinkingHeader = false;
+        const handleChunk = (chunk) => {
+            if (chunk.error)
+                throw new Error(chunk.error);
+            const thinkPiece = chunk.message?.thinking ?? "";
+            const contentPiece = chunk.message?.content ?? "";
+            if (thinkPiece) {
+                thinking += thinkPiece;
+                if (opts.writeStdout && think) {
+                    if (!thinkingHeader) {
+                        process.stderr.write("[thinking]\n");
+                        thinkingHeader = true;
+                    }
+                    process.stderr.write(thinkPiece);
+                }
+            }
+            if (contentPiece) {
+                content += contentPiece;
+                if (opts.writeStdout) {
+                    if (thinkingHeader) {
+                        process.stderr.write("\n---\n");
+                        thinkingHeader = false;
+                    }
+                    process.stdout.write(contentPiece);
+                }
+            }
+            last = chunk;
+        };
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                handleChunk(parseChunk(url, trimmed));
+            }
+        }
+        const trailing = buffer.trim();
+        if (trailing) {
+            handleChunk(parseChunk(url, trailing));
+        }
+        if (opts.writeStdout && !content && thinking) {
+            if (think)
+                process.stderr.write("\n---\n");
+            process.stdout.write(`${thinking}\n`);
+        }
+        else if (opts.writeStdout && content.length > 0 && !content.endsWith("\n")) {
+            process.stdout.write("\n");
+        }
+        return { content: content || thinking, thinking, chunk: last };
+    }
+    catch (err) {
+        const name = err instanceof Error ? err.name : "";
+        if (name === "AbortError") {
+            throw new Error(`Prompt timed out after ${opts.timeoutMs}ms (${url})`);
+        }
+        throw err;
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+export async function ollamaTags(baseUrl, timeoutMs) {
+    const url = `${baseUrl}/api/tags`;
+    const body = await ollamaGetJson(url, timeoutMs);
+    return body.models ?? [];
+}
+export async function ollamaShow(baseUrl, model, timeoutMs) {
+    const url = `${baseUrl}/api/show`;
+    return ollamaPostJson(url, { model }, timeoutMs);
+}
+export async function ollamaVersion(baseUrl, timeoutMs) {
+    try {
+        const body = await ollamaGetJson(`${baseUrl}/api/version`, timeoutMs);
+        return body.version;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function ollamaPs(baseUrl, timeoutMs) {
+    try {
+        const body = await ollamaGetJson(`${baseUrl}/api/ps`, timeoutMs);
+        return body.models ?? [];
+    }
+    catch {
+        return [];
+    }
+}
+function modelKey(name) {
+    return name.trim().toLowerCase();
+}
+export function psHasModel(models, name) {
+    const key = modelKey(name);
+    return models.some((m) => {
+        const n = (m.name ?? m.model ?? "").toLowerCase();
+        return n === key || n.startsWith(`${key}:`) || key.startsWith(`${n}:`);
+    });
+}
+function findPsModel(models, name) {
+    const key = modelKey(name);
+    return models.find((m) => {
+        const n = (m.name ?? m.model ?? "").toLowerCase();
+        return n === key || n.startsWith(`${key}:`) || key.startsWith(`${n}:`);
+    });
+}
+export function vramForModel(models, name) {
+    return findPsModel(models, name)?.size_vram;
+}
+export function contextLengthForModel(models, name) {
+    return findPsModel(models, name)?.context_length;
+}
+/**
+ * Capability filter: omitempty / empty means "unknown → treat as completion".
+ * Only skip when a non-empty capabilities array is present and lacks completion.
+ */
+export function isCompletionCapable(capabilities) {
+    if (capabilities == null || capabilities.length === 0)
+        return true;
+    return capabilities.includes("completion");
+}
+/**
+ * Vision-capable models (moondream, llava, …) often fail a text-only suite.
+ * Only true when capabilities are present and include vision — absent/empty → false
+ * (don't skip unknown older servers).
+ */
+export function isVisionCapable(capabilities) {
+    if (capabilities == null || capabilities.length === 0)
+        return false;
+    return capabilities.includes("vision");
+}
+/** True when capabilities are known and lack thinking (absent/empty → no warning). */
+export function shouldWarnNoThinking(capabilities) {
+    if (capabilities == null || capabilities.length === 0)
+        return false;
+    return !capabilities.includes("thinking");
+}
+/** Poll /api/ps until model is absent (or timeout). Returns elapsed ms. */
+export async function waitUntilUnloaded(baseUrl, model, timeoutMs, pollMs = 200) {
+    const started = Date.now();
+    while (Date.now() - started < timeoutMs) {
+        const models = await ollamaPs(baseUrl, Math.min(5000, timeoutMs));
+        if (!psHasModel(models, model)) {
+            return { unloaded: true, waitedMs: Date.now() - started };
+        }
+        await new Promise((r) => setTimeout(r, pollMs));
+    }
+    return { unloaded: false, waitedMs: Date.now() - started };
+}
+/** Request unload via keep_alive: 0 (no-op-ish if already unloaded after a short chat). */
+export async function ollamaUnload(baseUrl, model, timeoutMs) {
+    await ollamaChat({
+        baseUrl,
+        model,
+        messages: [{ role: "user", content: "ping" }],
+        stream: false,
+        writeStdout: false,
+        timeoutMs,
+        settings: { keep_alive: 0, num_predict: 1, think: false },
+    });
+}
+async function ollamaGetJson(url, timeoutMs) {
+    const controller = new AbortController();
+    const timer = timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs) : undefined;
+    try {
+        const res = await fetch(url, {
+            headers: { Accept: "application/json" },
+            signal: controller.signal,
+        });
+        if (!res.ok) {
+            throw new Error(`Ollama HTTP ${res.status} ${res.statusText} (${url})`);
+        }
+        const text = await res.text();
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            throw new Error(`Non-JSON response from ${url} (is something else on this port?): ${text.slice(0, 120)}`);
+        }
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+async function ollamaPostJson(url, body, timeoutMs) {
+    const controller = new AbortController();
+    const timer = timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs) : undefined;
+    try {
+        const res = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", Accept: "application/json" },
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+        if (!res.ok) {
+            const text = await res.text().catch(() => "");
+            throw new Error(`Ollama HTTP ${res.status} ${res.statusText}${text ? `: ${text}` : ""} (${url})`);
+        }
+        const text = await res.text();
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            throw new Error(`Non-JSON response from ${url} (is something else on this port?): ${text.slice(0, 120)}`);
+        }
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}

package/dist/paths.js

@@ -22,3 +22,7 @@ export function defaultConfigPath() {
 export function defaultResponsesDir() {
     return IS_INSTALLED ? path.join(USER_DIR, "responses") : projectPath("responses");
 }
+/** Default benchmark results dir (mirrors responses layout). */
+export function defaultBenchmarksDir() {
+    return IS_INSTALLED ? path.join(USER_DIR, "benchmarks") : projectPath("benchmarks");
+}