polymath-agent 0.4.0 → 0.5.0

package/README.md

@@ -42,7 +42,25 @@ beats a pricey generalist at edits. Polymath assigns the cheapest model that gen
 
 ```bash
 npm install -g polymath-agent
-poly login        # guided OpenRouter key setup
+poly setup        # guided: optionally install a local LLM (Ollama) + connect models
+```
+
+`poly setup` asks whether to install a local LLM, or skip the prompt with a flag:
+
+```bash
+poly setup --local                       # install Ollama + pull a model (RAM-aware default)
+poly setup --local -m qwen2.5-coder:7b   # choose the model
+poly setup --no-local                    # cloud only — just connect an OpenRouter key
+poly setup --local -y                    # non-interactive (accept defaults / auto-install)
+```
+
+Keep everything current with `poly update` (the CLI via npm, the Ollama runtime, and
+your local models) — add `--check` to only report what's available:
+
+```bash
+poly update            # update CLI + Ollama + re-pull local models
+poly update --check    # report-only
+poly update --self     # just the CLI   (also --ollama, --models)
 ```
 
 **From source** (no npm publish needed):
@@ -88,6 +106,8 @@ poly usage                                # cost by date + model
 
 | Command | What it does |
 |---|---|
+| `poly setup` | First-run: optionally install a local LLM (Ollama) + connect models. `--local` / `--no-local` / `-m <model>` / `-y`. |
+| `poly update` | Update the CLI (npm), the Ollama runtime, and local models. `--check`, `--self`, `--ollama`, `--models`. |
 | `poly login` | Connect/replace your OpenRouter API key (Claude-Code-style onboarding). |
 | `poly run [goal]` | Launch the interactive agent. Shows the recommended routing, then executes. |
 | `poly recommend <goal>` | Pre-run recommendation: cheapest / best-value / best-quality model combos + savings. |

package/dist/cli.js

@@ -2180,6 +2180,274 @@ function logCompletion(result, taskType, sessionId, command = "run") {
   return entry;
 }
 
+// src/setup/commands.ts
+import { execSync as execSync2 } from "node:child_process";
+
+// src/util/prompt.ts
+import readline2 from "node:readline";
+function interactive() {
+  return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+function ask2(question) {
+  return new Promise((resolve2) => {
+    const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (a) => {
+      rl.close();
+      resolve2(a.trim());
+    });
+  });
+}
+async function confirm(question, def = true) {
+  if (!interactive()) return def;
+  const hint = def ? "[Y/n]" : "[y/N]";
+  const a = (await ask2(`${question} ${hint} `)).toLowerCase();
+  if (!a) return def;
+  return /^y/.test(a);
+}
+async function select(question, items, render2) {
+  if (!interactive() || items.length <= 1) return items[0];
+  console.log(question);
+  items.forEach((it, i) => console.log(`  ${i + 1}) ${render2(it)}`));
+  const a = await ask2(`Choose [1-${items.length}] (default 1): `);
+  const n = parseInt(a, 10);
+  return Number.isInteger(n) && n >= 1 && n <= items.length ? items[n - 1] : items[0];
+}
+
+// src/setup/localllm.ts
+import { execSync, spawn } from "node:child_process";
+import os2 from "node:os";
+function suggestModels() {
+  const ramGb = Math.round(os2.totalmem() / 1024 ** 3);
+  const list = [];
+  if (ramGb >= 13) list.push({ id: "qwen2.5-coder:7b", label: "Qwen2.5 Coder 7B", sizeGb: 4.7, note: "best coding pick for ~16GB" });
+  list.push({ id: "llama3.2:3b", label: "Llama 3.2 3B", sizeGb: 2, note: "fast, light; great for cheap tasks" });
+  if (ramGb >= 30) list.push({ id: "qwen2.5-coder:14b", label: "Qwen2.5 Coder 14B", sizeGb: 9, note: "stronger coding for 32GB+" });
+  return list;
+}
+function totalRamGb() {
+  return Math.round(os2.totalmem() / 1024 ** 3);
+}
+function which(cmd) {
+  try {
+    execSync(process.platform === "win32" ? `where ${cmd}` : `command -v ${cmd}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ollamaInstalled() {
+  return which("ollama");
+}
+function ollamaVersion() {
+  try {
+    return execSync("ollama --version", { encoding: "utf8" }).trim();
+  } catch {
+    return null;
+  }
+}
+async function ollamaServerUp(baseUrl = "http://localhost:11434") {
+  try {
+    const res = await fetch(`${baseUrl.replace(/\/v1\/?$/, "")}/api/version`);
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function installedModels(baseUrl = "http://localhost:11434") {
+  try {
+    const res = await fetch(`${baseUrl.replace(/\/v1\/?$/, "")}/api/tags`);
+    if (!res.ok) return [];
+    const json = await res.json();
+    return (json.models ?? []).map((m) => m.name);
+  } catch {
+    return [];
+  }
+}
+function run(cmd, args) {
+  return new Promise((resolve2) => {
+    const child = spawn(cmd, args, { stdio: "inherit" });
+    child.on("error", () => resolve2(false));
+    child.on("exit", (code) => resolve2(code === 0));
+  });
+}
+function ollamaInstallPlan() {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    if (which("brew")) return { canAuto: true, command: { cmd: "brew", args: ["install", "ollama"] }, manual: "brew install ollama" };
+    return { canAuto: false, manual: "Install Homebrew (https://brew.sh) then `brew install ollama`, or download https://ollama.com/download" };
+  }
+  if (platform === "linux") {
+    return { canAuto: true, command: { cmd: "sh", args: ["-c", "curl -fsSL https://ollama.com/install.sh | sh"] }, manual: "curl -fsSL https://ollama.com/install.sh | sh" };
+  }
+  if (platform === "win32") {
+    if (which("winget")) return { canAuto: true, command: { cmd: "winget", args: ["install", "-e", "--id", "Ollama.Ollama"] }, manual: "winget install Ollama.Ollama" };
+    return { canAuto: false, manual: "Download the installer from https://ollama.com/download" };
+  }
+  return { canAuto: false, manual: "See https://ollama.com/download" };
+}
+async function ensureServer(baseUrl = "http://localhost:11434") {
+  if (await ollamaServerUp(baseUrl)) return true;
+  if (process.platform === "darwin" && which("brew")) {
+    await run("brew", ["services", "start", "ollama"]);
+  } else {
+    try {
+      const child = spawn("ollama", ["serve"], { stdio: "ignore", detached: true });
+      child.unref();
+    } catch {
+    }
+  }
+  for (let i = 0; i < 10; i++) {
+    if (await ollamaServerUp(baseUrl)) return true;
+    await delay(500);
+  }
+  return false;
+}
+function delay(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/setup/commands.ts
+async function runSetup(opts) {
+  console.log(c.bold("\n\u{1F527} Polymath setup\n"));
+  const config = loadConfig();
+  let wantLocal = opts.local;
+  if (wantLocal === void 0) {
+    wantLocal = await confirm(
+      `Install a local LLM (Ollama) for $0, offline, no-API-key runs? (RAM detected: ${totalRamGb()}GB)`,
+      true
+    );
+  }
+  if (wantLocal) {
+    await setupLocal(opts, config);
+  } else {
+    config.local.enabled = false;
+    saveConfig(config);
+    console.log(c.dim("Skipping local LLM. (You can run `poly setup --local` later.)"));
+  }
+  const freshConfig = loadConfig();
+  if (!resolveApiKey(freshConfig)) {
+    const wantKey = opts.yes ? false : await confirm("Connect an OpenRouter API key for cloud models (300+ models)?", !wantLocal);
+    if (wantKey) await runLogin();
+    else if (!wantLocal) console.log(c.yellow("No models configured yet \u2014 run `poly login` or `poly setup --local`."));
+  }
+  console.log(c.green("\n\u2713 Setup complete.") + c.dim('  Try: poly recommend "add a dark-mode toggle"  \xB7  poly run -w "..."'));
+}
+async function setupLocal(opts, config) {
+  if (!ollamaInstalled()) {
+    const plan = ollamaInstallPlan();
+    console.log(c.cyan("Local LLM runtime: Ollama is not installed."));
+    if (plan.canAuto && plan.command) {
+      const go = opts.yes || await confirm(`Install Ollama via \`${plan.command.cmd} ${plan.command.args.join(" ")}\`?`, true);
+      if (go) {
+        const ok = await run(plan.command.cmd, plan.command.args);
+        if (!ok) console.log(c.yellow("Auto-install failed. Manual: " + plan.manual));
+      } else {
+        console.log(c.dim("Manual install: " + plan.manual));
+      }
+    } else {
+      console.log(c.yellow("Install manually: " + plan.manual));
+    }
+  } else {
+    console.log(c.green("\u2713 Ollama present ") + c.dim(ollamaVersion() ?? ""));
+  }
+  if (!ollamaInstalled()) {
+    console.log(c.yellow("Ollama still not on PATH \u2014 re-run `poly setup --local` after installing."));
+    return;
+  }
+  process.stdout.write("Starting Ollama server\u2026 ");
+  const up = await ensureServer(config.local.baseUrl);
+  console.log(up ? c.green("ok") : c.yellow("could not confirm (start it with `ollama serve`)"));
+  const have = await installedModels(config.local.baseUrl);
+  let modelId = opts.model;
+  if (!modelId) {
+    const suggestions = suggestModels().filter((s) => !have.includes(s.id));
+    if (have.length && !suggestions.length) {
+      modelId = have[0];
+      console.log(c.dim(`Using already-installed model ${modelId}.`));
+    } else {
+      const pick = opts.yes ? suggestModels()[0] : await select(
+        "Pick a model to download:",
+        suggestModels(),
+        (s) => `${s.label}  (~${s.sizeGb}GB) \u2014 ${s.note}${have.includes(s.id) ? " [installed]" : ""}`
+      );
+      modelId = pick.id;
+    }
+  }
+  if (!have.includes(modelId)) {
+    console.log(c.cyan(`Downloading ${modelId}\u2026`));
+    const ok = await run("ollama", ["pull", modelId]);
+    if (!ok) {
+      console.log(c.yellow(`Could not pull ${modelId}. Run \`ollama pull ${modelId}\` manually.`));
+      return;
+    }
+  }
+  config.local.enabled = true;
+  saveConfig(config);
+  console.log(c.green(`\u2713 Local LLM ready: ${modelId} \u2192 local/${modelId} ($0). `) + c.dim("Enabled in config."));
+}
+function cmp(a, b) {
+  const pa = a.replace(/^v/, "").split(".").map((n) => parseInt(n, 10) || 0);
+  const pb = b.replace(/^v/, "").split(".").map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] ?? 0) !== (pb[i] ?? 0)) return (pa[i] ?? 0) - (pb[i] ?? 0);
+  }
+  return 0;
+}
+async function runUpdate(currentVersion, opts) {
+  const all = !opts.self && !opts.ollama && !opts.models;
+  console.log(c.bold("\n\u2B06\uFE0F  Polymath update") + (opts.check ? c.dim("  (check only)") : "") + "\n");
+  if (all || opts.self) {
+    let latest = "";
+    try {
+      latest = execSync2("npm view polymath-agent version", { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    } catch {
+      latest = "";
+    }
+    if (!latest) {
+      console.log(c.dim("CLI: could not reach npm registry."));
+    } else if (cmp(latest, currentVersion) > 0) {
+      console.log(c.yellow(`CLI: ${currentVersion} \u2192 ${latest} available.`));
+      if (!opts.check) {
+        const ok = await run("npm", ["install", "-g", `polymath-agent@${latest}`]);
+        console.log(ok ? c.green(`\u2713 Updated to ${latest}.`) : c.red("npm update failed (try: sudo npm i -g polymath-agent@latest)."));
+      } else {
+        console.log(c.dim("  Run `poly update` to install."));
+      }
+    } else {
+      console.log(c.green(`\u2713 CLI is up to date (${currentVersion}).`));
+    }
+  }
+  if (all || opts.ollama) {
+    if (!ollamaInstalled()) {
+      console.log(c.dim("Ollama: not installed (run `poly setup --local`)."));
+    } else if (opts.check) {
+      console.log(c.dim(`Ollama: ${ollamaVersion() ?? "present"} (update with \`poly update --ollama\`).`));
+    } else if (process.platform === "darwin") {
+      console.log(c.cyan("Updating Ollama\u2026"));
+      await run("brew", ["upgrade", "ollama"]).then((ok) => !ok && console.log(c.dim("  (brew upgrade skipped/failed)")));
+    } else if (process.platform === "linux") {
+      await run("sh", ["-c", "curl -fsSL https://ollama.com/install.sh | sh"]);
+    } else {
+      console.log(c.dim("Ollama: update via your installer (winget upgrade Ollama.Ollama)."));
+    }
+  }
+  if (all || opts.models) {
+    const config = loadConfig();
+    const models = await installedModels(config.local.baseUrl);
+    if (!models.length) {
+      console.log(c.dim("Models: none installed."));
+    } else if (opts.check) {
+      console.log(c.dim(`Models: ${models.join(", ")} (re-pull to update).`));
+    } else {
+      for (const m of models) {
+        console.log(c.cyan(`Updating ${m}\u2026`));
+        await run("ollama", ["pull", m]);
+      }
+    }
+  }
+  console.log("");
+}
+
 // src/tui/App.tsx
 import { useState, useEffect, useCallback } from "react";
 import { Box, Text, useApp, useInput } from "ink";
@@ -2189,7 +2457,7 @@ import Spinner from "ink-spinner";
 // src/agent/tools.ts
 import fs4 from "node:fs";
 import path2 from "node:path";
-import { execSync } from "node:child_process";
+import { execSync as execSync3 } from "node:child_process";
 var TOOL_SCHEMAS = [
   {
     type: "function",
@@ -2332,7 +2600,7 @@ function executeTool(name, argsJson, ctx) {
       }
       case "run_command": {
         if (!ctx.allowCommands) return { result: "Denied: run_command is disabled." };
-        const out = execSync(String(args.command), {
+        const out = execSync3(String(args.command), {
           cwd: ctx.cwd,
           encoding: "utf8",
           env: scrubbedEnv(),
@@ -3013,8 +3281,9 @@ function truncate2(s, n) {
 }
 
 // src/index.ts
+var VERSION = "0.5.0";
 var program = new Command();
-program.name("poly").description("Polymath \u2014 cost-optimized, multi-model TUI coding agent").version("0.4.0");
+program.name("poly").description("Polymath \u2014 cost-optimized, multi-model TUI coding agent").version(VERSION);
 function client(config) {
   return new OpenRouterClient({
     apiKey: resolveApiKey(config),
@@ -3085,6 +3354,14 @@ async function loadCatalog(config, refresh = false) {
   }
   return models;
 }
+program.command("setup").description("First-run setup: optionally install a local LLM (Ollama) and connect models").option("--local", "install a local LLM (Ollama) \u2014 skips the prompt").option("--no-local", "skip the local LLM \u2014 skips the prompt").option("-m, --model <id>", "local model to pull (e.g. qwen2.5-coder:7b)").option("-y, --yes", "accept defaults / auto-install without prompts", false).action(async (opts) => {
+  const argv = process.argv;
+  const local = argv.includes("--local") ? true : argv.includes("--no-local") ? false : void 0;
+  await runSetup({ local, model: opts.model, yes: !!opts.yes });
+});
+program.command("update").description("Update Polymath, the Ollama runtime, and local models").option("--check", "report available updates without installing", false).option("--self", "only the Polymath CLI", false).option("--ollama", "only the Ollama runtime", false).option("--models", "only the local models", false).action(async (opts) => {
+  await runUpdate(VERSION, { check: !!opts.check, self: !!opts.self, ollama: !!opts.ollama, models: !!opts.models });
+});
 program.command("login").description("Connect Polymath to OpenRouter (set/replace your API key)").action(async () => {
   await runLogin();
 });
@@ -3294,3 +3571,6 @@ program.parseAsync().catch((err) => {
   console.error(c.red(err?.message ?? String(err)));
   process.exit(1);
 });
+export {
+  VERSION
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polymath-agent",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Polymath — a cost-optimized, multi-model TUI coding agent. Decomposes work into typed tasks, routes each task to the cheapest capable model via OpenRouter, and logs real usage/cost by date + model.",
   "type": "module",
   "bin": {
@@ -18,7 +18,8 @@
     "dev": "tsx src/index.ts",
     "start": "node dist/cli.js",
     "prepare": "node esbuild.config.mjs",
-    "prepublishOnly": "npm run typecheck && npm run build"
+    "prepublishOnly": "npm run typecheck && npm run build",
+    "postinstall": "node -e \"process.stdout.isTTY && console.log('\\n\\u2728 Polymath ready. Run: poly setup   (connect models / optionally install a local LLM)\\n')\" || true"
   },
   "keywords": [
     "ai",