ollanet 0.4.1 → 0.6.0

package/dist/show.js

@@ -0,0 +1,131 @@
+/**
+ * Inspect a model on a reachable Ollama host (Modelfile, params, capabilities).
+ *
+ *   ollanet show studio gemma4-ctx32k
+ */
+import { envInt, ollamaBaseUrl, shortName } from "./hosts.js";
+import { ollamaShow } from "./ollama-chat.js";
+import { resolveTarget } from "./target.js";
+import { looksTuned } from "./tuned.js";
+function showTimeoutMs() {
+    return envInt("OLLAMA_SHOW_TIMEOUT_MS", 30_000);
+}
+function usage() {
+    console.error(`Usage:
+  ollanet show <machine> <model>
+  ollanet show --machine <name> --model <name>
+
+Examples:
+  ollanet show studio gemma4-ctx32k
+  ollanet show localhost llama3.2:1b --json
+
+Reads /api/show on that host — Modelfile, parameters, capabilities.
+Tuned Finetuna-style names are marked [tuned].
+
+Options:
+  --machine <name>   Host (discovered name, MagicDNS, hostname, or IP[:port])
+  --model <name>     Model to inspect
+  --json             Emit result JSON on stdout`);
+    process.exit(1);
+}
+function takeValue(args, flag) {
+    const value = args.shift();
+    if (!value) {
+        console.error(`${flag} requires a value`);
+        usage();
+    }
+    return value;
+}
+function parseArgs(argv) {
+    const args = [...argv];
+    let machineFlag;
+    let modelFlag;
+    let json = false;
+    const positional = [];
+    while (args.length > 0) {
+        const arg = args.shift();
+        if (arg === "--")
+            continue;
+        if (arg === "--help" || arg === "-h")
+            usage();
+        if (arg === "--json") {
+            json = true;
+            continue;
+        }
+        if (arg === "--machine") {
+            machineFlag = takeValue(args, "--machine");
+            continue;
+        }
+        if (arg === "--model") {
+            modelFlag = takeValue(args, "--model");
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            console.error(`Unknown flag: ${arg}`);
+            usage();
+        }
+        positional.push(arg);
+    }
+    const machine = machineFlag ?? positional[0];
+    const model = modelFlag ?? (machineFlag ? positional[0] : positional[1]);
+    if (positional.length > 2 || (machineFlag && modelFlag && positional.length > 0)) {
+        console.error("Too many arguments.");
+        usage();
+    }
+    return { machine, model, json };
+}
+export async function showModel(opts) {
+    const model = (opts.model ?? "").trim();
+    if (!model)
+        throw new Error("Model is required.");
+    const host = await resolveTarget(opts.machine, opts.config);
+    const info = await ollamaShow(ollamaBaseUrl(host), model, opts.timeoutMs ?? showTimeoutMs());
+    const tuned = looksTuned(model, { modelfile: info.modelfile, parameters: info.parameters });
+    return {
+        machine: shortName(host),
+        model,
+        endpoint: ollamaBaseUrl(host),
+        tuned,
+        capabilities: info.capabilities,
+        modelfile: info.modelfile,
+        parameters: info.parameters,
+        template: info.template,
+        system: info.system,
+        details: info.details,
+        modified_at: info.modified_at,
+    };
+}
+function printShow(result) {
+    const tag = result.tuned ? "  [tuned]" : "";
+    process.stdout.write(`${result.machine}  ${result.model}${tag}\n`);
+    process.stdout.write(`Endpoint: ${result.endpoint}\n`);
+    const d = result.details;
+    const meta = [d?.family, d?.parameter_size, d?.quantization_level].filter(Boolean).join(" · ");
+    if (meta)
+        process.stdout.write(`${meta}\n`);
+    if (result.capabilities?.length) {
+        process.stdout.write(`Capabilities: ${result.capabilities.join(", ")}\n`);
+    }
+    if (result.parameters?.trim()) {
+        process.stdout.write(`\nParameters:\n${result.parameters.trimEnd()}\n`);
+    }
+    if (result.modelfile?.trim()) {
+        process.stdout.write(`\nModelfile:\n${result.modelfile.trimEnd()}\n`);
+    }
+}
+export async function main() {
+    const parsed = parseArgs(process.argv.slice(2));
+    if (!parsed.machine || !parsed.model) {
+        if (!parsed.machine)
+            console.error("Machine is required.");
+        else
+            console.error("Model is required.");
+        usage();
+    }
+    const result = await showModel({ machine: parsed.machine, model: parsed.model });
+    if (parsed.json) {
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+        return;
+    }
+    printShow(result);
+}

package/dist/target.d.ts

@@ -0,0 +1,4 @@
+import { type AppConfig } from "./config.js";
+import { type HostTarget } from "./hosts.js";
+/** Resolve a machine name the same way pull / prompt / bench do. */
+export declare function resolveTarget(machine: string, config?: Partial<AppConfig>): Promise<HostTarget>;

package/dist/target.js

@@ -0,0 +1,18 @@
+import { configFromPartial, loadConfig } from "./config.js";
+import { discoverHosts, resolveHost, shortName } from "./hosts.js";
+/** Resolve a machine name the same way pull / prompt / bench do. */
+export async function resolveTarget(machine, config) {
+    const query = machine.trim();
+    if (!query)
+        throw new Error("Machine is required.");
+    const app = config ? configFromPartial(config) : await loadConfig();
+    const { hosts } = await discoverHosts({
+        hosts: app.hosts,
+        discovery: app.discovery,
+    });
+    const host = resolveHost(hosts, query);
+    if (!host.online && !host.isSelf && host.source === "tailscale") {
+        throw new Error(`Machine "${shortName(host)}" appears offline.`);
+    }
+    return host;
+}

package/dist/tuned.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Heuristic for Finetuna-style named variants (and similar host-side tunes).
+ * Scan uses the name only — no extra /api/show per model.
+ */
+export declare function looksTuned(name: string, extra?: {
+    modelfile?: string;
+    parameters?: string;
+}): boolean;

package/dist/tuned.js

@@ -0,0 +1,17 @@
+/**
+ * Heuristic for Finetuna-style named variants (and similar host-side tunes).
+ * Scan uses the name only — no extra /api/show per model.
+ */
+const CTX = /-ctx\d+k(\b|-|$)/i;
+const FLASH = /-flash(\b|-|$)/i;
+export function looksTuned(name, extra) {
+    const n = (name ?? "").trim();
+    if (!n)
+        return false;
+    if (n.toLowerCase().includes("finetuna"))
+        return true;
+    if (CTX.test(n) || FLASH.test(n))
+        return true;
+    const blob = `${extra?.modelfile ?? ""}\n${extra?.parameters ?? ""}`.toLowerCase();
+    return blob.includes("finetuna");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ollanet",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "description": "Discover and talk to Ollama on any reachable network — CLI, MCP, and a Node library",
   "type": "module",
   "bin": {
@@ -29,6 +29,11 @@
     "ollanet": "tsx src/cli.ts",
     "scan": "tsx src/cli.ts scan",
     "prompt": "tsx src/cli.ts prompt",
+    "compare": "tsx src/cli.ts compare",
+    "pull": "tsx src/cli.ts pull",
+    "show": "tsx src/cli.ts show",
+    "rm": "tsx src/cli.ts rm",
+    "ps": "tsx src/cli.ts ps",
     "chats": "tsx src/cli.ts chats",
     "bench": "tsx src/cli.ts bench",
     "mcp": "tsx src/cli.ts mcp",
@@ -36,9 +41,10 @@
     "typecheck": "tsc --noEmit",
     "test": "tsc -p tsconfig.build.json && node scripts/fix-dts-extensions.mjs && node --test test/*.test.mjs",
     "test:only": "node --test test/*.test.mjs",
+    "ship": "pnpm --dir site run ship",
     "site:dev": "pnpm --dir site dev",
     "site:build": "pnpm --dir site build",
-    "site:deploy": "pnpm --dir site deploy"
+    "site:deploy": "pnpm --dir site run ship"
   },
   "keywords": [
     "ollama",