@freesyntax/notch-cli 0.5.20 → 0.5.22

package/dist/chunk-FZVPGJJW.js

@@ -0,0 +1,511 @@
+import {
+  OLLAMA_CLOUD_BASE_URL,
+  OLLAMA_LOCAL_BASE_URL,
+  detectDaemon,
+  formatBytes,
+  isCloudBaseUrl,
+  isCloudModel,
+  listModels,
+  pullModel,
+  showModel
+} from "./chunk-GFVLHUSS.js";
+import {
+  clearOllamaCreds,
+  ollamaCredsPath,
+  readOllamaCreds,
+  writeOllamaCreds
+} from "./chunk-KCAR5DOB.js";
+import {
+  findByokProvider
+} from "./chunk-JXQ4HZ47.js";
+
+// src/commands/ollama-launch.ts
+import fs from "fs/promises";
+import path from "path";
+import readline from "readline";
+import chalk from "chalk";
+var readCreds = readOllamaCreds;
+var writeCreds = writeOllamaCreds;
+var clearCreds = clearOllamaCreds;
+var credsPath = ollamaCredsPath;
+function parseFlags(argv) {
+  const out = { positional: [], cloud: false, yes: false, help: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--cloud") out.cloud = true;
+    else if (a === "-y" || a === "--yes") out.yes = true;
+    else if (a === "--help" || a === "-h") out.help = true;
+    else if (a === "--model" || a === "-m") out.model = argv[++i];
+    else if (a.startsWith("--model=")) out.model = a.slice("--model=".length);
+    else if (a === "--host") out.host = argv[++i];
+    else if (a.startsWith("--host=")) out.host = a.slice("--host=".length);
+    else if (a === "--api-key") out.apiKey = argv[++i];
+    else if (a.startsWith("--api-key=")) out.apiKey = a.slice("--api-key=".length);
+    else if (a === "--compat") {
+      const v = argv[++i];
+      if (v === "openai" || v === "anthropic") out.compat = v;
+    } else if (a.startsWith("--compat=")) {
+      const v = a.slice("--compat=".length);
+      if (v === "openai" || v === "anthropic") out.compat = v;
+    } else if (!a.startsWith("-")) {
+      out.positional.push(a);
+    }
+  }
+  return out;
+}
+async function resolveEndpoint(flags) {
+  let baseUrl;
+  if (flags.host) {
+    baseUrl = flags.host;
+  } else if (flags.cloud) {
+    baseUrl = OLLAMA_CLOUD_BASE_URL;
+  } else if (process.env.OLLAMA_HOST) {
+    baseUrl = process.env.OLLAMA_HOST.startsWith("http") ? process.env.OLLAMA_HOST : `http://${process.env.OLLAMA_HOST}`;
+  } else {
+    baseUrl = OLLAMA_LOCAL_BASE_URL;
+  }
+  const mode = isCloudBaseUrl(baseUrl) ? "cloud" : "local";
+  let apiKey = flags.apiKey ?? process.env.OLLAMA_API_KEY ?? void 0;
+  if (!apiKey && mode === "cloud") {
+    const stored = await readCreds();
+    if (stored && stored.endpoint === baseUrl) {
+      apiKey = stored.apiKey;
+    }
+  }
+  return { baseUrl, apiKey, mode };
+}
+async function promptLine(prompt, opts = {}) {
+  if (!process.stdin.isTTY) {
+    throw new Error("Interactive prompt requested but stdin is not a TTY.");
+  }
+  if (!opts.mask) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise((resolve) => {
+      rl.question(prompt, (ans) => resolve(ans));
+    });
+    rl.close();
+    return answer.trim();
+  }
+  return new Promise((resolve, reject) => {
+    process.stdout.write(prompt);
+    const stdin = process.stdin;
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+    let buf = "";
+    const onData = (chunk) => {
+      for (const byte of chunk) {
+        if (byte === 3) {
+          cleanup();
+          process.stdout.write("\n");
+          reject(new Error("Cancelled"));
+          return;
+        }
+        if (byte === 13 || byte === 10) {
+          cleanup();
+          process.stdout.write("\n");
+          resolve(buf.trim());
+          return;
+        }
+        if (byte === 127 || byte === 8) {
+          if (buf.length > 0) {
+            buf = buf.slice(0, -1);
+            process.stdout.write("\b \b");
+          }
+          continue;
+        }
+        if (byte < 32) continue;
+        buf += String.fromCharCode(byte);
+        process.stdout.write("*");
+      }
+    };
+    const cleanup = () => {
+      stdin.removeListener("data", onData);
+      stdin.setRawMode(wasRaw ?? false);
+      stdin.pause();
+    };
+    stdin.on("data", onData);
+  });
+}
+function pickFromList(items, title) {
+  if (items.length === 0) return Promise.resolve(null);
+  if (!process.stdin.isTTY) return Promise.resolve(items[0] ?? null);
+  return new Promise((resolve) => {
+    let cursor = 0;
+    const render = (first) => {
+      if (!first) process.stdout.write(`\x1B[${items.length + 2}A\x1B[J`);
+      process.stdout.write(chalk.gray(`  ${title} (\u2191\u2193 to move, Enter to select, Esc to cancel)
+
+`));
+      for (let i = 0; i < items.length; i++) {
+        const pointer = i === cursor ? chalk.cyan("\u276F") : " ";
+        const label = i === cursor ? chalk.bold(items[i]) : chalk.gray(items[i]);
+        process.stdout.write(`  ${pointer} ${label}
+`);
+      }
+    };
+    render(true);
+    const stdin = process.stdin;
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+    const onKey = (key) => {
+      const s = key.toString();
+      if (s === "\x1B[A") {
+        cursor = (cursor - 1 + items.length) % items.length;
+        render(false);
+      } else if (s === "\x1B[B") {
+        cursor = (cursor + 1) % items.length;
+        render(false);
+      } else if (s === "\r" || s === "\n") {
+        cleanup();
+        resolve(items[cursor] ?? null);
+      } else if (s === "\x1B" || s === "") {
+        cleanup();
+        resolve(null);
+      }
+    };
+    const cleanup = () => {
+      stdin.removeListener("data", onKey);
+      stdin.setRawMode(wasRaw ?? false);
+      stdin.pause();
+    };
+    stdin.on("data", onKey);
+  });
+}
+function renderProgressLine(ev, lastStatus) {
+  if (ev.kind === "progress") {
+    const width = 30;
+    const filled = Math.max(0, Math.min(width, Math.round(ev.percent / 100 * width)));
+    const bar = `${"\u2588".repeat(filled)}${"\u2591".repeat(width - filled)}`;
+    const suffix = `${ev.percent.toFixed(1).padStart(5)}%  ${formatBytes(ev.completed)}/${formatBytes(ev.total)}`;
+    const label = ev.message || lastStatus.label;
+    lastStatus.label = label;
+    process.stdout.write(`\r  ${chalk.cyan(bar)}  ${chalk.gray(suffix)}  ${chalk.dim(label)}\x1B[K`);
+  } else if (ev.kind === "status") {
+    lastStatus.label = ev.message;
+    process.stdout.write(`\r  ${chalk.gray(ev.message)}\x1B[K`);
+  } else {
+    process.stdout.write("\n");
+  }
+}
+async function persistOllamaChoice(projectRoot, opts) {
+  const p = path.resolve(projectRoot, ".notch.json");
+  let current = {};
+  try {
+    const raw = await fs.readFile(p, "utf-8");
+    current = JSON.parse(raw);
+  } catch (err) {
+    const code = err.code;
+    if (code && code !== "ENOENT") throw err;
+  }
+  const byok = {
+    provider: opts.providerId,
+    model: opts.modelId
+  };
+  if (opts.baseUrl) byok.baseUrl = opts.baseUrl;
+  if (opts.apiShape) byok.apiShape = opts.apiShape;
+  current.byok = byok;
+  await fs.writeFile(p, JSON.stringify(current, null, 2) + "\n", "utf-8");
+}
+async function cmdList(flags) {
+  const { baseUrl, apiKey, mode } = await resolveEndpoint(flags);
+  const ok = await detectDaemon(baseUrl, { apiKey });
+  if (!ok) {
+    printNotReachable(baseUrl, mode);
+    return 1;
+  }
+  let rows;
+  try {
+    rows = await listModels(baseUrl, { apiKey });
+  } catch (err) {
+    console.error(chalk.red(`  ${err.message}`));
+    return 1;
+  }
+  if (rows.length === 0) {
+    console.log(chalk.gray(`
+  No models installed at ${baseUrl}.`));
+    console.log(chalk.gray(`  Pull one:  notch ollama pull llama3.2:latest
+`));
+    return 0;
+  }
+  const header = `  ${"name".padEnd(36)} ${"params".padEnd(8)} ${"quant".padEnd(10)} ${"size".padStart(8)}`;
+  console.log(chalk.gray(`
+  ${mode === "cloud" ? "Ollama Cloud" : "Ollama local"}  @  ${baseUrl}
+`));
+  console.log(chalk.gray(header));
+  console.log(chalk.gray(`  ${"-".repeat(header.length - 2)}`));
+  for (const r of rows) {
+    console.log(
+      `  ${chalk.white(r.name.padEnd(36))} ${chalk.gray(r.parameterSize.padEnd(8))} ${chalk.gray(r.quantization.padEnd(10))} ${chalk.gray(formatBytes(r.sizeBytes))}`
+    );
+  }
+  console.log("");
+  return 0;
+}
+async function cmdPull(flags) {
+  const modelName = flags.positional[0] ?? flags.model;
+  if (!modelName) {
+    console.error(chalk.red("  Usage: notch ollama pull <model>"));
+    return 2;
+  }
+  const { baseUrl, apiKey, mode } = await resolveEndpoint(flags);
+  const ok = await detectDaemon(baseUrl, { apiKey });
+  if (!ok) {
+    printNotReachable(baseUrl, mode);
+    return 1;
+  }
+  console.log(chalk.cyan(`
+  Pulling ${chalk.bold(modelName)} from ${baseUrl}...
+`));
+  const lastStatus = { label: "" };
+  try {
+    for await (const ev of pullModel(modelName, baseUrl, { apiKey })) {
+      renderProgressLine(ev, lastStatus);
+    }
+  } catch (err) {
+    process.stdout.write("\n");
+    console.error(chalk.red(`  Pull failed: ${err.message}`));
+    return 1;
+  }
+  console.log(chalk.green(`  \u2713 ${modelName} ready.
+`));
+  return 0;
+}
+async function cmdStatus(flags) {
+  const { baseUrl, apiKey, mode } = await resolveEndpoint(flags);
+  const ok = await detectDaemon(baseUrl, { apiKey });
+  console.log("");
+  console.log(chalk.gray("  Endpoint"), chalk.white(baseUrl));
+  console.log(chalk.gray("  Mode    "), chalk.white(mode));
+  console.log(chalk.gray("  Auth    "), apiKey ? chalk.green("yes (api key)") : chalk.yellow("none"));
+  console.log(chalk.gray("  Reach   "), ok ? chalk.green("ok") : chalk.red("unreachable"));
+  console.log("");
+  return ok ? 0 : 1;
+}
+async function cmdLogin(flags) {
+  const endpoint = flags.host ?? OLLAMA_CLOUD_BASE_URL;
+  console.log(chalk.cyan(`
+  Ollama login \u2014 paste your API key for ${endpoint}`));
+  console.log(chalk.gray(`  Get one at https://ollama.com/settings/keys
+`));
+  let apiKey = flags.apiKey;
+  if (!apiKey) {
+    apiKey = await promptLine("  API key: ", { mask: true });
+  }
+  if (!apiKey) {
+    console.error(chalk.red("  No key provided."));
+    return 2;
+  }
+  const reachable = await detectDaemon(endpoint, { apiKey, timeoutMs: 8e3 });
+  if (!reachable) {
+    console.error(chalk.red(`  Could not authenticate against ${endpoint} with the provided key.`));
+    return 1;
+  }
+  await writeCreds({ apiKey, endpoint, createdAt: Date.now() });
+  console.log(chalk.green(`  \u2713 Key stored at ${credsPath()}`));
+  console.log(chalk.gray(`  The CLI will auto-load it when you run \`notch ollama --cloud\`.
+`));
+  return 0;
+}
+async function cmdLogout(_flags) {
+  const existed = await readCreds();
+  await clearCreds();
+  if (existed) {
+    console.log(chalk.green(`
+  \u2713 Cleared Ollama credentials for ${existed.endpoint}
+`));
+  } else {
+    console.log(chalk.gray("\n  No stored Ollama credentials.\n"));
+  }
+  return 0;
+}
+async function cmdLaunch(flags, opts) {
+  const { baseUrl, apiKey, mode } = await resolveEndpoint(flags);
+  const ok = await detectDaemon(baseUrl, { apiKey });
+  if (!ok) {
+    printNotReachable(baseUrl, mode);
+    return 1;
+  }
+  let rows = [];
+  try {
+    rows = await listModels(baseUrl, { apiKey });
+  } catch (err) {
+    console.error(chalk.red(`  Could not list models: ${err.message}`));
+    return 1;
+  }
+  let chosen = flags.model;
+  if (!chosen) {
+    if (rows.length === 0) {
+      console.log(chalk.yellow(`
+  No models installed at ${baseUrl}.`));
+      const suggest = ["qwen3-coder:30b", "gpt-oss:20b", "llama3.2:latest"];
+      const pick = await pickFromList(
+        suggest,
+        "Pick one to pull"
+      );
+      if (!pick) return 0;
+      chosen = pick;
+      const pullCode = await cmdPull({ ...flags, positional: [chosen] });
+      if (pullCode !== 0) return pullCode;
+    } else {
+      const pick = await pickFromList(rows.map((r) => r.name), "Select a model");
+      if (!pick) return 0;
+      chosen = pick;
+    }
+  } else if (mode === "local" && !rows.some((r) => r.name === chosen) && !isCloudModel(chosen)) {
+    const consent = flags.yes ? true : (await promptLine(`  Model ${chosen} isn't installed. Pull now? [Y/n] `)).toLowerCase() !== "n";
+    if (consent) {
+      const pullCode = await cmdPull({ ...flags, positional: [chosen] });
+      if (pullCode !== 0) return pullCode;
+    } else {
+      console.error(chalk.red("  Aborted: model not installed."));
+      return 1;
+    }
+  }
+  if (mode === "local") {
+    try {
+      const info = await showModel(chosen, baseUrl, { apiKey });
+      if (typeof info.contextLength === "number" && info.contextLength < 64e3) {
+        console.warn(
+          chalk.yellow(
+            `  \u26A0 ${chosen} exposes only ${info.contextLength.toLocaleString()} tokens of context. Notch recommends \u226564,000 \u2014 agent loops will truncate aggressively.`
+          )
+        );
+      }
+    } catch {
+    }
+  }
+  const compat = flags.compat ?? "openai";
+  let providerId;
+  if (mode === "cloud") {
+    providerId = "ollama-cloud";
+    if (flags.compat === "anthropic") {
+      console.warn(chalk.yellow(
+        "  ! --compat anthropic is ignored for Ollama Cloud (only the local daemon exposes /v1/messages)."
+      ));
+    }
+  } else if (compat === "anthropic") {
+    providerId = "ollama-anthropic";
+  } else {
+    providerId = "ollama";
+  }
+  const providerInfo = findByokProvider(providerId);
+  if (!providerInfo) {
+    console.error(chalk.red(`  Internal: provider ${providerId} missing from catalog.`));
+    return 1;
+  }
+  try {
+    await persistOllamaChoice(opts.projectRoot, {
+      providerId,
+      modelId: chosen,
+      // Only persist baseUrl when it differs from the provider default
+      // — otherwise the catalog default carries forward and survives
+      // future CLI upgrades.
+      baseUrl: baseUrl === providerInfo.baseUrl || mode === "cloud" && baseUrl === OLLAMA_CLOUD_BASE_URL ? void 0 : baseUrl,
+      apiShape: providerInfo.apiShape
+    });
+  } catch (err) {
+    console.warn(chalk.yellow(`  ! Could not write .notch.json: ${err.message}`));
+  }
+  console.log("");
+  console.log(chalk.green(`  \u2713 Ollama configured.`));
+  console.log(chalk.gray("    provider "), chalk.white(providerId));
+  console.log(chalk.gray("    model    "), chalk.white(chosen));
+  console.log(chalk.gray("    endpoint "), chalk.white(baseUrl));
+  console.log(chalk.gray("    compat   "), chalk.white(providerInfo.apiShape ?? "openai"));
+  console.log("");
+  if (mode === "cloud" && apiKey && !process.env.OLLAMA_API_KEY) {
+    console.log(chalk.gray(`  Ollama Cloud key loaded from  ${credsPath()}`));
+  }
+  console.log(chalk.gray(`  Run:  notch  (the selection is saved in .notch.json)`));
+  console.log("");
+  return 0;
+}
+function printNotReachable(baseUrl, mode) {
+  console.error(chalk.red(`
+  Cannot reach Ollama at ${baseUrl}.`));
+  if (mode === "local") {
+    console.error(chalk.gray(`  Start the daemon:  ollama serve`));
+    console.error(chalk.gray(`  Or install:        https://ollama.com/download
+`));
+  } else {
+    console.error(chalk.gray(`  Check that OLLAMA_API_KEY is set (notch ollama login).
+`));
+  }
+}
+function printHelp() {
+  console.log(`
+  Notch CLI \u2014 Ollama integration
+
+  Usage:
+    notch ollama                 Interactive setup + launch
+    notch ollama launch          Same as above (explicit)
+    notch ollama list            List installed / cloud models
+    notch ollama pull <model>    Pull a model with a progress bar
+    notch ollama status          Show daemon reachability
+    notch ollama login           Store OLLAMA_API_KEY for Cloud
+    notch ollama logout          Clear stored Ollama credentials
+    notch ollama bench           Benchmark multiple models on a prompt
+
+  Flags (for every subcommand):
+    --cloud                      Use https://ollama.com (Ollama Cloud)
+    --host <url>                 Override the daemon base URL
+    --model, -m <name>           Model to use / pull / bench
+    --api-key <key>              API key override (env: OLLAMA_API_KEY)
+    --compat <openai|anthropic>  Wire protocol for local daemon
+    -y, --yes                    Auto-confirm destructive prompts
+
+  Examples:
+    notch ollama                 Detect daemon, pick a model, save to .notch.json
+    notch ollama --cloud         Target Ollama Cloud
+    notch ollama --compat anthropic --model qwen3-coder:30b
+    notch ollama pull llama3.2:latest
+    notch ollama bench "summarize this repo" --model llama3.2,qwen3-coder:30b
+`);
+}
+async function runOllamaCli(argv, cwd) {
+  const flags = parseFlags(argv);
+  if (flags.help && flags.positional.length === 0) {
+    printHelp();
+    return 0;
+  }
+  const sub = flags.positional[0] ?? "launch";
+  const subFlags = { ...flags, positional: flags.positional.slice(1) };
+  switch (sub) {
+    case "launch":
+    case void 0:
+      return cmdLaunch(subFlags, { projectRoot: cwd });
+    case "list":
+    case "ls":
+      return cmdList(subFlags);
+    case "pull":
+      return cmdPull(subFlags);
+    case "status":
+      return cmdStatus(subFlags);
+    case "login":
+      return cmdLogin(subFlags);
+    case "logout":
+      return cmdLogout(subFlags);
+    case "bench": {
+      const { runOllamaBench } = await import("./ollama-bench-5V5CCOCQ.js");
+      return runOllamaBench(subFlags, { projectRoot: cwd });
+    }
+    case "help":
+      printHelp();
+      return 0;
+    default:
+      console.error(chalk.red(`  Unknown subcommand: ollama ${sub}`));
+      printHelp();
+      return 2;
+  }
+}
+
+export {
+  parseFlags,
+  resolveEndpoint,
+  renderProgressLine,
+  persistOllamaChoice,
+  printNotReachable,
+  runOllamaCli
+};

package/dist/chunk-GFVLHUSS.js

@@ -0,0 +1,155 @@
+// src/providers/ollama.ts
+var OLLAMA_LOCAL_BASE_URL = "http://localhost:11434";
+var OLLAMA_CLOUD_BASE_URL = "https://ollama.com";
+var DEFAULT_TIMEOUT_MS = 5e3;
+function authHeaders(apiKey) {
+  return apiKey ? { Authorization: `Bearer ${apiKey}` } : {};
+}
+function joinUrl(baseUrl, path) {
+  const root = baseUrl.replace(/\/+$/, "");
+  const suffix = path.startsWith("/") ? path : `/${path}`;
+  return `${root}${suffix}`;
+}
+async function detectDaemon(baseUrl = OLLAMA_LOCAL_BASE_URL, opts = {}) {
+  try {
+    const res = await fetch(joinUrl(baseUrl, "/api/tags"), {
+      signal: AbortSignal.timeout(opts.timeoutMs ?? DEFAULT_TIMEOUT_MS),
+      headers: authHeaders(opts.apiKey)
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function listModels(baseUrl = OLLAMA_LOCAL_BASE_URL, opts = {}) {
+  const res = await fetch(joinUrl(baseUrl, "/api/tags"), {
+    signal: AbortSignal.timeout(opts.timeoutMs ?? DEFAULT_TIMEOUT_MS),
+    headers: authHeaders(opts.apiKey)
+  });
+  if (!res.ok) {
+    throw new Error(`Ollama ${baseUrl} returned ${res.status} for /api/tags`);
+  }
+  const body = await res.json();
+  const models = body.models ?? [];
+  return models.map((m) => ({
+    name: m.name,
+    parameterSize: m.details?.parameter_size ?? "\u2014",
+    quantization: m.details?.quantization_level ?? "\u2014",
+    sizeBytes: m.size ?? 0,
+    modifiedAt: m.modified_at
+  }));
+}
+async function showModel(modelName, baseUrl = OLLAMA_LOCAL_BASE_URL, opts = {}) {
+  const res = await fetch(joinUrl(baseUrl, "/api/show"), {
+    method: "POST",
+    signal: AbortSignal.timeout(opts.timeoutMs ?? DEFAULT_TIMEOUT_MS),
+    headers: { "Content-Type": "application/json", ...authHeaders(opts.apiKey) },
+    body: JSON.stringify({ name: modelName })
+  });
+  if (!res.ok) {
+    throw new Error(`Ollama /api/show(${modelName}) returned ${res.status}`);
+  }
+  const body = await res.json();
+  const info = body.model_info ?? {};
+  let contextLength;
+  for (const [key, value] of Object.entries(info)) {
+    if (key.endsWith(".context_length") && typeof value === "number") {
+      contextLength = value;
+      break;
+    }
+  }
+  return {
+    contextLength,
+    parameterSize: body.details?.parameter_size,
+    family: body.details?.family,
+    modelInfo: info
+  };
+}
+async function* pullModel(modelName, baseUrl = OLLAMA_LOCAL_BASE_URL, opts = {}) {
+  const res = await fetch(joinUrl(baseUrl, "/api/pull"), {
+    method: "POST",
+    signal: opts.signal,
+    headers: { "Content-Type": "application/json", ...authHeaders(opts.apiKey) },
+    body: JSON.stringify({ name: modelName, stream: true })
+  });
+  if (!res.ok || !res.body) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`Ollama /api/pull returned ${res.status}${text ? `: ${text.slice(0, 200)}` : ""}`);
+  }
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  let done = false;
+  while (!done) {
+    const { value, done: streamDone } = await reader.read();
+    if (streamDone) break;
+    buf += decoder.decode(value, { stream: true });
+    let nl = buf.indexOf("\n");
+    while (nl >= 0) {
+      const line = buf.slice(0, nl).trim();
+      buf = buf.slice(nl + 1);
+      nl = buf.indexOf("\n");
+      if (!line) continue;
+      let frame;
+      try {
+        frame = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (frame.error) {
+        throw new Error(`Ollama pull error: ${frame.error}`);
+      }
+      const status = frame.status ?? "";
+      if (status === "success") {
+        done = true;
+        break;
+      }
+      if (typeof frame.total === "number" && typeof frame.completed === "number" && frame.total > 0) {
+        yield {
+          kind: "progress",
+          message: status,
+          completed: frame.completed,
+          total: frame.total,
+          percent: Math.min(100, frame.completed / frame.total * 100)
+        };
+      } else if (status) {
+        yield { kind: "status", message: status };
+      }
+    }
+  }
+  yield { kind: "done" };
+}
+function isCloudBaseUrl(baseUrl) {
+  try {
+    const host = new URL(baseUrl).hostname;
+    return host === "ollama.com" || host.endsWith(".ollama.com");
+  } catch {
+    return false;
+  }
+}
+function isCloudModel(modelName) {
+  return /(^|[:\-])cloud$/i.test(modelName) || modelName.endsWith(":cloud");
+}
+function formatBytes(n) {
+  if (!n || n <= 0) return "       \u2014";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let v = n;
+  let i = 0;
+  while (v >= 1024 && i < units.length - 1) {
+    v /= 1024;
+    i++;
+  }
+  return `${v.toFixed(v >= 10 ? 0 : 1)} ${units[i]}`.padStart(8);
+}
+
+export {
+  OLLAMA_LOCAL_BASE_URL,
+  OLLAMA_CLOUD_BASE_URL,
+  detectDaemon,
+  listModels,
+  showModel,
+  pullModel,
+  isCloudBaseUrl,
+  isCloudModel,
+  formatBytes
+};