turbollm 1.7.1 → 1.7.3

package/README.md

@@ -196,9 +196,11 @@ the detail:
   the model draws when a comparison, trend, or hierarchy is genuinely worth a visual.
 - **Live artifacts** — `html`, `svg`, and `mermaid` replies render as **sandboxed, offline
   previews** shown as an image, with one-click export to **PNG / JPEG / SVG / animated GIF / HTML**.
-- **Personas** — pick a style (Default · **Designer** · Concise · Detailed · Blunt · Formal · Tutor ·
-  Creative · Research) per conversation, no prompt-wrangling required. The **Designer** persona
-  produces polished, self-contained, previewable designs by default.
+- **Agents** — pick a style (Default · **Designer** · Concise · Detailed · Blunt · Formal · Tutor ·
+  Creative · Research · **Lite** · **Code**) per conversation, no prompt-wrangling required. The
+  **Designer** persona produces polished, self-contained, previewable designs by default; **Lite**
+  strips the hidden prompt to the bare minimum for the fastest responses. See below for editing
+  built-ins or creating your own.
 - **Edit, regenerate, delete, copy** any message; **persistent, searchable conversations**
   with rename, delete, and **auto-generated titles**, organized into **drag-resizable,
   collapsible folders** you create/rename/move conversations into.
@@ -219,17 +221,17 @@ the detail:
 </details>
 
 <details>
-<summary><strong>🤖 Background agents — long-running tasks that don't tie up your chat</strong></summary>
+<summary><strong>🤖 Customize → Agents — edit any built-in, or build your own</strong></summary>
 
 <br/>
 
-- **Launch an agent and walk away.** The **Agents** screen runs tasks in the daemon, separate from
-  the chat tab — describe the task, pick which tools it may use (web search / fetch URL / run code),
-  and let it work.
-- **Live, reconnectable progress.** Watch the run stream in real time; navigate away or reload and
-  the view **reconnects** to the in-progress output. Runs **queue** behind any active run and
-  **persist** across restarts.
-- **Cancel anytime**, and review completed runs (messages + the tool calls they made) later.
+- **Edit any built-in agent in place** — system prompt, which shared skills it uses, and which
+  tools it may call — with a one-click **Reset** back to the original.
+- **Create your own agent** from scratch: a name, description, and system prompt, plus a
+  checklist of which shared skills and which tools it's allowed to use (everything on by
+  default). Pick it from the same in-chat agent picker as the built-ins.
+- **MCP tools grouped by server** in the tool checklist — one toggle selects or deselects an
+  entire server's tools at once, or expand it to pick individually.
 
 </details>
 
@@ -446,7 +448,7 @@ Use `--config <file>` to point at an alternate config (its directory becomes the
 
 ## Requirements
 
-- **Node.js 22 or newer** — enforced at startup with a clear message. <https://nodejs.org>
+- **Node.js 22.13.0 or newer** — enforced at startup with a clear message. <https://nodejs.org>
 - **Windows, macOS, or Linux.**
 - A GPU is recommended but **not required** — a CPU build is provisioned as a fallback.
 - On Windows, the first time the auto-downloaded `llama-server` runs, SmartScreen/Defender may
@@ -492,7 +494,7 @@ Prefer Open WebUI's chat breadth? It works great pointed at TurboLLM's OpenAI en
 
 ## Troubleshooting
 
-- **`TurboLLM requires Node.js 22 or newer`** — upgrade Node: <https://nodejs.org>.
+- **`TurboLLM requires Node.js 22.13.0 or newer`** — upgrade Node: <https://nodejs.org>.
 - **Model won't load / OOM** — pick a smaller quant (the VRAM verdict warns you), lower GPU
   offload, or close other GPU apps. Failures surface in the Engines screen with the engine log.
 - **Windows Defender / SmartScreen prompt** — that's the upstream `llama-server` binary on
@@ -519,7 +521,7 @@ node dist/cli.js --port 6996
 Frontend hot-reload: `cd web && npm run dev` (proxies `/api` and `/v1` to the daemon on
 :6996).
 
-**Stack:** Node ≥22 · TypeScript · Hono · `node:sqlite` · tsup — and a React 19 + Tailwind v4 +
+**Stack:** Node ≥22.13 · TypeScript · Hono · `node:sqlite` · tsup — and a React 19 + Tailwind v4 +
 shadcn/ui frontend. One TypeScript codebase, shipped as an npm package.
 
 ---

package/bin/turbollm.mjs

@@ -1,25 +1,29 @@
-#!/usr/bin/env node
-// Hand-written launcher shim — NOT bundled by tsup. It runs before the bundled
-// daemon (dist/cli.js) loads, so it can do two things that must happen before
-// node:sqlite is imported (the bundle hoists that import, emitting an experimental
-// warning that PowerShell renders as a scary red error block on every run):
-//   1. Guard the Node version with a friendly message (node:sqlite needs Node 22+).
-//   2. Register a 'warning' filter that swallows the node:sqlite experimental notice
-//      while still printing every other warning.
-// Then it hands off to the real CLI via dynamic import (same process; argv intact).
-const major = Number(process.versions.node.split('.')[0])
-if (major < 22) {
-  process.stderr.write(
-    `TurboLLM requires Node.js 22 or newer.\n` +
-      `You are running Node.js ${process.versions.node}.\n` +
-      `Please upgrade: https://nodejs.org\n`,
-  )
-  process.exit(1)
-}
-
-process.on('warning', (w) => {
-  if (w.name === 'ExperimentalWarning' && /SQLite/i.test(w.message)) return
-  process.stderr.write(`${w.stack ?? `${w.name}: ${w.message}`}\n`)
-})
-
-await import('../dist/cli.js')
+#!/usr/bin/env node
+// Hand-written launcher shim — NOT bundled by tsup. It runs before the bundled
+// daemon (dist/cli.js) loads, so it can do two things that must happen before
+// node:sqlite is imported (the bundle hoists that import, emitting an experimental
+// warning that PowerShell renders as a scary red error block on every run):
+//   1. Guard the Node version with a friendly message (node:sqlite needs Node 22.13+ —
+//      that's when node:sqlite became available WITHOUT the --experimental-sqlite flag;
+//      on 22.5.0-22.12.x it's registered only behind that flag, so importing it bare
+//      throws ERR_UNKNOWN_BUILTIN_MODULE: "No such built-in module: node:sqlite"
+//      (GitHub #40) even though `node -v` reports 22.x).
+//   2. Register a 'warning' filter that swallows the node:sqlite experimental notice
+//      while still printing every other warning.
+// Then it hands off to the real CLI via dynamic import (same process; argv intact).
+const [major, minor] = process.versions.node.split('.').map(Number)
+if (major < 22 || (major === 22 && minor < 13)) {
+  process.stderr.write(
+    `TurboLLM requires Node.js 22.13.0 or newer (needs node:sqlite unflagged).\n` +
+      `You are running Node.js ${process.versions.node}.\n` +
+      `Please upgrade: https://nodejs.org\n`,
+  )
+  process.exit(1)
+}
+
+process.on('warning', (w) => {
+  if (w.name === 'ExperimentalWarning' && /SQLite/i.test(w.message)) return
+  process.stderr.write(`${w.stack ?? `${w.name}: ${w.message}`}\n`)
+})
+
+await import('../dist/cli.js')

package/dist/chunk-TPYU5ZAX.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+
+// src/agents/distiller.ts
+import { readFileSync, readdirSync, statSync, existsSync } from "fs";
+import { join } from "path";
+
+// src/engines/compat.ts
+function engineAcceptsFormat(engineKind, format) {
+  if (engineKind === "mlx") return format === "mlx";
+  if (engineKind === "vllm") return format === "mlx";
+  return format === "gguf";
+}
+var ENGINE_MODEL_ALIAS = "default_model";
+function engineModelAlias(engineKind) {
+  return engineKind === "mlx" || engineKind === "vllm" || engineKind === "sglang" ? ENGINE_MODEL_ALIAS : null;
+}
+var VENDOR_DISPLAY = {
+  nvidia: "NVIDIA",
+  amd: "AMD",
+  intel: "Intel",
+  apple: "Apple Silicon",
+  unknown: "no detected GPU"
+};
+var PLATFORM_DISPLAY = {
+  darwin: "macOS",
+  win32: "Windows",
+  linux: "Linux"
+};
+function platformName(p) {
+  return PLATFORM_DISPLAY[p] ?? p;
+}
+function platformReason(allowed) {
+  const names = allowed.map(platformName);
+  const joined = names.length <= 1 ? names.join("") : `${names.slice(0, -1).join(", ")} & ${names[names.length - 1]}`;
+  return `${joined} only`;
+}
+function evaluateVariant(p, r) {
+  if (r.platform && !r.platform.includes(p.platform)) {
+    return { ok: false, reason: platformReason(r.platform) };
+  }
+  if (r.arch && !r.arch.includes(p.arch)) {
+    return { ok: false, reason: `Needs ${r.arch.join(" / ")}` };
+  }
+  if (r.gpuVendor && !r.gpuVendor.includes(p.gpuVendor)) {
+    const needs = r.gpuVendor.map((v) => VENDOR_DISPLAY[v]).join(" / ");
+    const article = /^[NAEIO]/.test(needs) ? "an" : "a";
+    return { ok: false, reason: `Needs ${article} ${needs} GPU \u2014 you have ${VENDOR_DISPLAY[p.gpuVendor]}` };
+  }
+  if (r.minVramMb !== void 0 && p.vramMb > 0 && p.vramMb < r.minVramMb) {
+    const gb = Math.round(r.minVramMb / 1024);
+    return { ok: false, reason: `Needs ~${gb} GB VRAM` };
+  }
+  return { ok: true };
+}
+
+// src/agents/distiller.ts
+var DISTILL_SYSTEM = `You write a single reusable SKILL from the material provided. A skill captures a repeatable approach so it can be applied to similar future tasks.
+
+Output a JSON object: {"name": <short kebab-case id>, "description": <one sentence: when to use this skill>, "procedure": <concise step-by-step procedure, markdown>}
+
+Rules:
+- The skill must be GENERAL and reusable, not a one-off answer to this specific input.
+- "name" is a short kebab-case identifier (e.g. "csv-summary", "extract-config-values").
+- "description" is one sentence describing WHEN to apply it.
+- "procedure" is a concise, numbered set of steps \u2014 the how.
+- If the material does not contain a clear reusable approach, output {"name": null, "description": null, "procedure": null}.
+Respond with ONLY the JSON object, nothing else.`;
+async function distill(d, material) {
+  const ms = d.manager.status();
+  const target = d.manager.target();
+  if (ms.state !== "running" || !ms.model || !target) return { name: null, description: null, procedure: null };
+  const model = engineModelAlias(d.registry.active()?.kind ?? "") ?? ms.model.key;
+  try {
+    const res = await fetch(`${target}/v1/chat/completions`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model,
+        messages: [
+          { role: "system", content: DISTILL_SYSTEM },
+          { role: "user", content: `Material:
+
+${material.slice(0, 24e3)}
+
+Write ONE reusable skill as raw JSON \u2014 no markdown fences.` }
+        ],
+        temperature: 0.3,
+        max_tokens: 800,
+        reasoning_budget: 0,
+        chat_template_kwargs: { enable_thinking: false },
+        response_format: { type: "json_object" },
+        stream: false
+      }),
+      signal: AbortSignal.timeout(9e4)
+    });
+    if (!res.ok) return { name: null, description: null, procedure: null };
+    const data = await res.json();
+    let txt = data.choices?.[0]?.message?.content ?? "";
+    txt = txt.replace(/<think>[\s\S]*?<\/think>/gi, "").replace(/```json|```/gi, "").trim();
+    const m = txt.match(/\{[\s\S]*\}/);
+    if (!m) return { name: null, description: null, procedure: null };
+    const j = JSON.parse(m[0]);
+    const valid = (s) => typeof s === "string" && s.trim() && s.toLowerCase() !== "null" ? s.trim() : null;
+    const name = valid(j.name);
+    const procedure = valid(j.procedure);
+    if (!name || !procedure) return { name: null, description: null, procedure: null };
+    return { name: name.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64), description: valid(j.description) ?? "", procedure };
+  } catch {
+    return { name: null, description: null, procedure: null };
+  }
+}
+function distillFromConversation(d, transcript) {
+  const text = transcript.map((m) => `${m.role.toUpperCase()}: ${m.content}`).join("\n");
+  return distill(d, `A successful completed task:
+
+${text}`);
+}
+var FOLDER_TEXT = /\.(md|txt|json|ya?ml|csv|js|ts|py|sh|html?|css)$/i;
+function collectFolderFiles(folder, max) {
+  const files = [];
+  const walk = (dir, depth) => {
+    if (depth > 4 || files.length >= max) return;
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (files.length >= max) return;
+      const p = join(dir, e.name);
+      if (e.isDirectory()) {
+        walk(p, depth + 1);
+        continue;
+      }
+      if (!FOLDER_TEXT.test(e.name)) continue;
+      try {
+        if (statSync(p).size > 2e5) continue;
+        const content = readFileSync(p, "utf8").slice(0, 6e3).trim();
+        if (content) files.push({ name: e.name, content });
+      } catch {
+      }
+    }
+  };
+  walk(folder, 0);
+  return files;
+}
+async function distillSkillsFromFolder(d, folder, opts = {}) {
+  if (!existsSync(folder) || !statSync(folder).isDirectory()) return [];
+  const max = opts.max ?? 12;
+  const files = collectFolderFiles(folder, max);
+  if (!files.length) return [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < files.length; i++) {
+    const f = files[i];
+    opts.onProgress?.(i, files.length, f.name);
+    const s = await distill(d, `A reusable approach captured in "${f.name}":
+
+${f.content}`);
+    if (s.name && s.procedure && !seen.has(s.name)) {
+      seen.add(s.name);
+      out.push(s);
+    }
+  }
+  return out;
+}
+
+export {
+  engineAcceptsFormat,
+  engineModelAlias,
+  evaluateVariant,
+  distillFromConversation,
+  distillSkillsFromFolder
+};