@tiagojct/subsub 0.20.0 → 0.22.0

package/dist/web.js

@@ -13,20 +13,15 @@
  * - Without an open page for a while (and with nothing waiting), the server
  *   stops by itself, so a shortcut can start it without a terminal.
  */
-import { spawn } from "node:child_process";
 import { randomBytes, timingSafeEqual } from "node:crypto";
-import { createReadStream, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, statSync, writeFileSync, appendFileSync } from "node:fs";
+import { createReadStream, existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync, appendFileSync } from "node:fs";
 import { createServer } from "node:http";
 import { homedir } from "node:os";
-import { basename, dirname, extname, join, normalize, relative, resolve, sep } from "node:path";
-import { StringDecoder } from "node:string_decoder";
+import { basename, dirname, extname, join, normalize, relative, sep } from "node:path";
 import { agentDirFor, chooseCwd, PACKAGE_DIR, packageVersion } from "./cli.js";
-import { configPath, expand, loadConfig, RECOMMENDED_MODELS, readConfigFile, saveConfig, uiLanguage, withStarbuck } from "./config.js";
+import { configPath, loadConfig, RECOMMENDED_MODELS, readConfigFile, saveConfig, uiLanguage, withStarbuck } from "./config.js";
 import { TESTED_MODELS } from "./init.js";
 import { KEY_PROVIDERS, saveApiKey } from "./keys.js";
-import { NOTE_DIRS, obsidianRoot, SETTINGS_DIR } from "./layout.js";
-import { field, frontMatter } from "./notes.js";
-import { realish, within } from "./paths.js";
 export function parseWebArgs(args) {
     const o = { port: 0, open: true, librarian: false, here: false, idleMinutes: 10, piArgs: [] };
     for (let i = 0; i < args.length; i++) {
@@ -51,127 +46,12 @@ export function parseWebArgs(args) {
 export { uiLanguage } from "./config.js";
 // ---------------------------------------------------------------- providers (API keys)
 export { KEY_PROVIDERS, saveApiKey } from "./keys.js";
-/** pi as a child process in RPC mode. Strict JSONL: records end at LF only. */
-export class Agent {
-    proc;
-    decoder = new StringDecoder("utf8");
-    buf = "";
-    n = 0;
-    pending = new Map();
-    listeners = new Set();
-    stderr = "";
-    onExit;
-    command;
-    args;
-    cwd;
-    env;
-    constructor(command, args, cwd, env) {
-        this.command = command;
-        this.args = args;
-        this.cwd = cwd;
-        this.env = env;
-    }
-    start(extra = []) {
-        this.buf = "";
-        this.decoder = new StringDecoder("utf8");
-        const proc = spawn(this.command, [...this.args, ...extra], { cwd: this.cwd, env: this.env, stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
-        this.proc = proc;
-        proc.stdout.on("data", (chunk) => this.feed(this.decoder.write(chunk)));
-        proc.stderr.on("data", (d) => {
-            this.stderr = (this.stderr + d.toString()).slice(-20_000);
-        });
-        proc.once("exit", (code) => {
-            if (this.proc !== proc)
-                return;
-            this.proc = undefined;
-            for (const p of this.pending.values()) {
-                clearTimeout(p.timer);
-                p.reject(new Error(`pi stopped (code ${code}). ${this.stderr.slice(-500)}`));
-            }
-            this.pending.clear();
-            this.onExit?.(code);
-        });
-    }
-    feed(text) {
-        this.buf += text;
-        let i;
-        while ((i = this.buf.indexOf("\n")) >= 0) {
-            const line = this.buf.slice(0, i).replace(/\r$/, "");
-            this.buf = this.buf.slice(i + 1);
-            if (!line.trim())
-                continue;
-            let rec;
-            try {
-                rec = JSON.parse(line);
-            }
-            catch {
-                continue;
-            }
-            if (rec.type === "response" && typeof rec.id === "string" && this.pending.has(rec.id)) {
-                const p = this.pending.get(rec.id);
-                this.pending.delete(rec.id);
-                clearTimeout(p.timer);
-                if (rec.success === false)
-                    p.reject(new Error(rec.error ?? `${rec.command} failed`));
-                else
-                    p.resolve(rec.data);
-                continue;
-            }
-            for (const l of this.listeners)
-                l(rec);
-        }
-    }
-    on(l) {
-        this.listeners.add(l);
-        return () => this.listeners.delete(l);
-    }
-    write(rec) {
-        const stdin = this.proc?.stdin;
-        if (!stdin || !stdin.writable)
-            throw new Error("pi is not running");
-        stdin.write(`${JSON.stringify(rec)}\n`);
-    }
-    request(cmd, timeoutMs = 30_000) {
-        const id = `w${++this.n}`;
-        return new Promise((resolvePromise, reject) => {
-            const timer = setTimeout(() => {
-                this.pending.delete(id);
-                reject(new Error(`pi did not answer ${String(cmd.type)} in time`));
-            }, timeoutMs);
-            this.pending.set(id, { resolve: resolvePromise, reject, timer });
-            try {
-                this.write({ ...cmd, id });
-            }
-            catch (err) {
-                clearTimeout(timer);
-                this.pending.delete(id);
-                reject(err);
-            }
-        });
-    }
-    async stop() {
-        const proc = this.proc;
-        if (!proc)
-            return;
-        this.proc = undefined;
-        for (const p of this.pending.values()) {
-            clearTimeout(p.timer);
-            p.reject(new Error("pi was stopped"));
-        }
-        this.pending.clear();
-        await new Promise((done) => {
-            const t = setTimeout(() => {
-                proc.kill("SIGKILL");
-                done();
-            }, 3000);
-            proc.once("exit", () => {
-                clearTimeout(t);
-                done();
-            });
-            proc.kill();
-        });
-    }
-}
+// ---------------------------------------------------------------- files (shared with the terminal screens)
+import { allowedFile, listNotes, openExternal, openFile, OPENABLE, wikilinkTarget } from "./files.js";
+export { allowedFile, listNotes, openExternal, OPENABLE, wikilinkTarget };
+// ---------------------------------------------------------------- pi in RPC mode (src/rpc.ts)
+import { Agent, findLibrary, isDialog, Side, withHints } from "./rpc.js";
+export { Agent };
 // ---------------------------------------------------------------- helpers
 const TYPES = {
     ".html": "text/html; charset=utf-8",
@@ -186,41 +66,6 @@ const TYPES = {
 const NOTE_TYPES = new Set([".md", ".markdown"]);
 /** Images that a note shows (a figure cut out of a PDF, for example). */
 const IMAGE_TYPES = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".gif": "image/gif", ".webp": "image/webp" };
-/** Files that the Open button may hand to the system (never programs or scripts). */
-export const OPENABLE = new Set([".md", ".markdown", ".txt", ".pdf", ".bib", ".csv", ".qmd"]);
-/** A file inside the working folder or the Sub-Sub folder, judged by its real path, so a link cannot point outside. */
-export function allowedFile(raw, cwd, vault) {
-    // expand() resolves against the process folder: use it for "~" only.
-    const target = resolve(cwd, raw.startsWith("~") ? expand(raw) : raw);
-    const real = realish(target);
-    const inside = within(real, realish(cwd)) || Boolean(vault && within(real, realish(vault)));
-    return inside && existsSync(target) && statSync(target).isFile() ? target : undefined;
-}
-/** The note a [[wikilink]] names: the first <folder>/<name>.md in the Sub-Sub folder, as Obsidian would find it. */
-export function wikilinkTarget(name, root) {
-    const file = name.endsWith(".md") ? name : `${name}.md`;
-    return ["", ...NOTE_DIRS, SETTINGS_DIR].map((d) => join(root, d, file)).find((f) => existsSync(f));
-}
-/** The notes in the Sub-Sub folders, newest first (dot folders such as Research/.plans left out). */
-export function listNotes(root, max = 300) {
-    const out = [];
-    for (const d of [...NOTE_DIRS, SETTINGS_DIR]) {
-        let names = [];
-        try {
-            names = readdirSync(join(root, d), { recursive: true });
-        }
-        catch {
-            continue;
-        }
-        for (const n of names) {
-            if (!n.endsWith(".md") || n.split(/[\\/]/).some((x) => x.startsWith(".")))
-                continue;
-            const path = join(root, d, n);
-            out.push({ path, rel: join(d, n), modified: statSync(path).mtimeMs });
-        }
-    }
-    return out.sort((a, b) => b.modified - a.modified).slice(0, max);
-}
 const CSP = [
     "default-src 'none'",
     "script-src 'self'",
@@ -232,14 +77,6 @@ const CSP = [
     "form-action 'none'",
     "frame-ancestors 'none'",
 ].join("; ");
-function readText(path) {
-    try {
-        return readFileSync(path, "utf8");
-    }
-    catch {
-        return "";
-    }
-}
 function same(a, b) {
     const x = Buffer.from(a);
     const y = Buffer.from(b);
@@ -285,20 +122,6 @@ function alive(pid) {
         return err.code === "EPERM";
     }
 }
-/** Open a URL or a file with the system's default program. */
-export function openExternal(target) {
-    const opts = { detached: true, stdio: "ignore", windowsHide: true };
-    let child;
-    if (process.platform === "darwin")
-        child = spawn("open", [target], opts);
-    // rundll32 hands the target to the default program without cmd.exe parsing it.
-    else if (process.platform === "win32")
-        child = spawn("rundll32", ["url.dll,FileProtocolHandler", target], opts);
-    else
-        child = spawn("xdg-open", [target], opts);
-    child.on("error", () => { });
-    child.unref();
-}
 /**
  * Start the web server and pi. Resolves when both are listening; the caller
  * decides whether to open a browser. Used by `subsub web` and by the tests.
@@ -321,7 +144,7 @@ export async function startWeb(opts, env = process.env, log = () => { }) {
     const clients = new Set();
     const dialogs = new Map();
     let subsubState = null;
-    let lastFind = null;
+    const side = new Side();
     let busy = false;
     let lastSeen = Date.now();
     let restarting = false;
@@ -345,27 +168,14 @@ export async function startWeb(opts, env = process.env, log = () => { }) {
     }
     agent.on((ev) => {
         if (ev.type === "extension_ui_request") {
-            if (["select", "confirm", "input", "editor"].includes(ev.method)) {
+            if (isDialog(ev)) {
                 dialogs.set(ev.id, ev);
                 broadcast(ev);
             }
-            else if (ev.method === "setStatus" && ev.statusKey === "subsub.web") {
-                try {
-                    subsubState = ev.statusText ? JSON.parse(ev.statusText) : null;
-                }
-                catch {
-                    subsubState = null;
-                }
+            else if (side.take(ev) === "state") {
+                subsubState = side.state;
                 broadcast({ type: "subsub_state", state: subsubState });
             }
-            else if (ev.method === "setStatus" && ev.statusKey === "subsub.find") {
-                try {
-                    lastFind = ev.statusText ? JSON.parse(ev.statusText) : null;
-                }
-                catch {
-                    lastFind = null;
-                }
-            }
             else if (ev.method === "notify") {
                 broadcast(ev);
             }
@@ -409,13 +219,7 @@ export async function startWeb(opts, env = process.env, log = () => { }) {
             out.session = await agent.request({ type: "get_state" });
             lastSession = out.session.sessionFile ?? lastSession;
             out.messages = (await agent.request({ type: "get_messages" })).messages;
-            const commands = (await agent.request({ type: "get_commands" })).commands;
-            // RPC has no argument hints: read them from the prompt files.
-            out.commands = commands.map((c) => {
-                const front = c.source === "prompt" && c.sourceInfo?.path ? frontMatter(readText(c.sourceInfo.path)) : undefined;
-                const hint = front && field(front, "argument-hint");
-                return hint ? { ...c, hint } : c;
-            });
+            out.commands = withHints((await agent.request({ type: "get_commands" })).commands);
         }
         catch (err) {
             out.error = err.message;
@@ -697,8 +501,7 @@ export async function startWeb(opts, env = process.env, log = () => { }) {
                     const q = (url.searchParams.get("q") ?? "").replace(/\s+/g, " ").trim().slice(0, 200);
                     if (!q)
                         return send(res, 200, { q, items: [] });
-                    await agent.request({ type: "prompt", message: `/subsub-find ${q}` });
-                    return send(res, 200, lastFind?.q === q ? lastFind : { q, items: [] });
+                    return send(res, 200, await findLibrary(agent, side, q));
                 }
                 case "POST /api/session/name": {
                     const body = await readJson(req);
@@ -741,10 +544,7 @@ export async function startWeb(opts, env = process.env, log = () => { }) {
                     // Documents only: a file that the model wrote must never be run.
                     if (!OPENABLE.has(extname(target).toLowerCase()))
                         return send(res, 403, { error: "Sub-Sub opens only notes and documents (.md, .txt, .pdf, .bib, .csv, .qmd)." });
-                    if (vault && within(target, vault) && obsidianRoot(vault))
-                        openExternal(`obsidian://open?path=${encodeURIComponent(target)}`);
-                    else
-                        openExternal(target);
+                    openFile(target, vault);
                     return send(res, 200, { ok: true });
                 }
                 case "POST /api/quit":

package/dist/words.js

@@ -0,0 +1,26 @@
+/**
+ * The plain words of the web view (actions, suggestions, names of tools, in English and Portuguese), for the terminal screens.
+ * web/i18n.js is a browser module with no imports; it is loaded here as it is, so the two views never differ.
+ */
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { PACKAGE_DIR } from "./cli.js";
+let words;
+/** A dynamic import: a static one would pull a file outside src/ into the TypeScript build. */
+export function loadWords() {
+    words ??= import(__rewriteRelativeImportExtension(pathToFileURL(join(PACKAGE_DIR, "web", "i18n.js")).href));
+    return words;
+}
+/** What a tool is called while it runs ("zotero_find_items" is "search the library"); unknown tools keep their name. */
+export function toolWord(w, lang, name) {
+    const short = name.replace(/^(zotero|scholar)_/, "");
+    return w.TOOLS[lang][short] ?? w.TOOLS.en[short] ?? name;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiagojct/subsub",
-  "version": "0.20.0",
+  "version": "0.22.0",
   "description": "Sub-Sub: a research assistant that works from your own Zotero library, in the browser or the terminal, built on pi",
   "type": "module",
   "license": "MIT",

package/scripts/make-themes.mjs

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+// Writes the pi themes of Sub-Sub (themes/subsub-<name>-<scheme>.json) from the colours in the front matter of
+// DESIGN.md and the role map in scripts/plate.json. The Researcher uses Prussian blue as its accent (glauca), the
+// Librarian madder (try-works). Errors have no colour of their own, removals are muted ink (the strike-through is
+// drawn by the code), and every meaning also has a glyph or a word, so the themes work for readers who do not see the washes.
+//
+//   node scripts/make-themes.mjs
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), "..");
+const SCHEMA = "https://raw.githubusercontent.com/earendil-works/pi/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json";
+
+/** The `colors:` block of the DESIGN.md front matter as {token: "#rrggbb"}. */
+export function designColors(markdown) {
+	const colors = {};
+	let inBlock = false;
+	for (const line of markdown.split("\n")) {
+		if (/^colors:\s*$/.test(line)) inBlock = true;
+		else if (inBlock && /^\S/.test(line)) break;
+		else if (inBlock) {
+			const m = line.match(/^\s+([a-z0-9-]+):\s*"(#[0-9a-fA-F]{6})"\s*$/);
+			if (m) colors[m[1]] = m[2].toLowerCase();
+		}
+	}
+	return colors;
+}
+
+
+const CUBE = [0, 95, 135, 175, 215, 255];
+/** The RGB of an xterm-256 colour index from 16 to 255 (the 16 system colours depend on the terminal). */
+export function xterm256(i) {
+	if (i >= 232) return [8 + (i - 232) * 10, 8 + (i - 232) * 10, 8 + (i - 232) * 10];
+	const n = i - 16;
+	return [CUBE[Math.floor(n / 36)], CUBE[Math.floor(n / 6) % 6], CUBE[n % 6]];
+}
+const toRgb = (h) => [1, 3, 5].map((k) => parseInt(h.slice(k, k + 2), 16));
+const luminance = (rgb) => {
+	const [r, g, b] = rgb.map((v) => v / 255).map((v) => (v <= 0.03928 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4));
+	return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+};
+export function contrastRatio(a, b) {
+	const [hi, lo] = [luminance(a), luminance(b)].sort((x, y) => y - x);
+	return (hi + 0.05) / (lo + 0.05);
+}
+
+/** The xterm-256 index nearest to a colour that reaches `min` contrast against `against` (the closest index with enough contrast, or the one with the most). */
+export function nearest256(hex, against, min) {
+	const want = toRgb(hex);
+	const ranked = [];
+	for (let i = 16; i < 256; i++) {
+		const c = xterm256(i);
+		ranked.push({ i, d: (c[0] - want[0]) ** 2 * 0.3 + (c[1] - want[1]) ** 2 * 0.59 + (c[2] - want[2]) ** 2 * 0.11, k: against ? contrastRatio(c, against) : Infinity });
+	}
+	ranked.sort((a, b) => a.d - b.d);
+	return (ranked.find((r) => r.k >= min) ?? ranked.sort((a, b) => b.k - a.k)[0]).i;
+}
+
+// Contrast that each colour variable needs against the terminal's own background: text 4.5, lines and bullets 3, rules none.
+const NEEDS = { ink: 4.5, muted: 4.5, faint: 4.5, prussian: 4.5, madder: 4.5, sap: 4.5, gamboge: 4.5, mark: 3, rule: 0 };
+// Roles whose background is left to the terminal in the 256-colour themes: a wash that is quantised to the cube loses its contrast.
+const DEFAULT_BG = ["userMessageBg", "customMessageBg", "toolPendingBg", "toolSuccessBg", "toolErrorBg", "searchMatchBg"];
+
+/** The same theme with xterm-256 indexes, for terminals without truecolor. */
+function to256(theme) {
+	const v = theme.vars;
+	const sheet = toRgb(v.sheet);
+	const vars = {};
+	for (const name of Object.keys(NEEDS)) vars[name] = nearest256(v[name], sheet, NEEDS[name]);
+	vars.accent = vars[Object.keys(NEEDS).find((n) => v[n] === v.accent)];
+	// The selection needs the text colour to stay readable on it.
+	vars.wash = nearest256(v.wash, xterm256(vars.ink), 4.5);
+	const colors = { ...theme.colors };
+	for (const r of DEFAULT_BG) colors[r] = "";
+	return { ...theme, name: `${theme.name}-256`, vars, colors, export: theme.export };
+}
+
+/** {"subsub-glauca-dark": theme, "subsub-glauca-dark-256": theme, ...} for every theme and scheme of the plate file. */
+export function buildThemes(designMd, plate) {
+	const design = designColors(designMd);
+	const out = {};
+	for (const [name, mode] of Object.entries(plate.themes)) {
+		for (const scheme of ["dark", "light"]) {
+			const vars = {};
+			for (const [v, key] of Object.entries(plate.tokens[scheme])) {
+				if (!design[key]) throw new Error(`DESIGN.md has no colour "${key}" (${scheme} ${v})`);
+				vars[v] = design[key];
+			}
+			vars.accent = vars[mode.accent];
+			vars.wash = vars[mode.wash];
+			const colors = {};
+			for (const [role, ref] of Object.entries(plate.roles)) colors[role] = ref === "$accent" ? "accent" : ref === "$wash" ? "wash" : ref;
+			const id = `subsub-${name}-${scheme}`;
+			out[id] = { $schema: SCHEMA, name: id, vars, colors, export: { pageBg: vars.sheet, cardBg: vars.field, infoBg: vars.sunk } };
+			out[`${id}-256`] = to256(out[id]);
+		}
+	}
+	return out;
+}
+
+function main() {
+	const design = fs.readFileSync(path.join(ROOT, "DESIGN.md"), "utf8");
+	const plate = JSON.parse(fs.readFileSync(path.join(ROOT, "scripts", "plate.json"), "utf8"));
+	fs.mkdirSync(path.join(ROOT, "themes"), { recursive: true });
+	for (const [id, theme] of Object.entries(buildThemes(design, plate))) {
+		fs.writeFileSync(path.join(ROOT, "themes", `${id}.json`), JSON.stringify(theme, null, "\t") + "\n");
+		console.log(`themes/${id}.json`);
+	}
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) main();

package/scripts/plate.json

@@ -0,0 +1,35 @@
+{
+	"tokens": {
+		"light": {
+			"sheet": "sheet", "sunk": "sunk-field", "field": "plate-field", "ink": "copperplate-ink", "muted": "ink-muted", "faint": "ink-faint", "rule": "fine-rule", "mark": "plate-mark",
+			"prussian": "prussian-blue", "prussianWash": "prussian-wash", "madder": "madder", "madderWash": "madder-wash", "sap": "sap-green", "sapWash": "sap-wash", "gamboge": "gamboge", "gambogeWash": "gamboge-wash"
+		},
+		"dark": {
+			"sheet": "steel-ground", "sunk": "steel-sunk", "field": "steel-field", "ink": "steel-line", "muted": "steel-muted", "faint": "steel-faint", "rule": "steel-fine-rule", "mark": "steel-plate-mark",
+			"prussian": "steel-prussian", "prussianWash": "steel-prussian-wash", "madder": "steel-madder", "madderWash": "steel-madder-wash", "sap": "steel-sap", "sapWash": "steel-sap-wash", "gamboge": "steel-gamboge", "gambogeWash": "steel-gamboge-wash"
+		}
+	},
+	"themes": {
+		"glauca": { "accent": "prussian", "wash": "prussianWash" },
+		"try-works": { "accent": "madder", "wash": "madderWash" }
+	},
+	"roles": {
+		"text": "ink", "userMessageText": "ink", "customMessageText": "ink", "toolTitle": "ink", "mdHeading": "ink", "mdCode": "ink", "mdCodeBlock": "ink", "error": "ink",
+		"muted": "muted", "toolOutput": "muted", "mdQuote": "muted", "toolDiffContext": "muted", "thinkingText": "muted", "toolDiffRemoved": "muted",
+		"dim": "faint", "mdLinkUrl": "faint", "syntaxComment": "faint",
+		"border": "mark", "mdQuoteBorder": "mark", "mdListBullet": "mark",
+		"borderMuted": "rule", "mdHr": "rule", "mdCodeBlockBorder": "rule", "scrollbarTrack": "rule", "thinkingOff": "rule",
+		"scrollbarThumb": "faint",
+		"accent": "$accent", "borderAccent": "$accent", "bashMode": "$accent", "customMessageLabel": "$accent", "thinkingXhigh": "$accent", "thinkingMax": "$accent",
+		"mdLink": "prussian", "thinkingHigh": "prussian",
+		"success": "sap", "toolDiffAdded": "sap",
+		"warning": "gamboge",
+		"selectedBg": "$wash",
+		"searchMatchBg": "gambogeWash", "searchMatchText": "ink",
+		"userMessageBg": "field", "toolSuccessBg": "field",
+		"customMessageBg": "sunk", "toolErrorBg": "sunk",
+		"toolPendingBg": "gambogeWash",
+		"syntaxKeyword": "prussian", "syntaxNumber": "prussian", "syntaxFunction": "ink", "syntaxVariable": "ink", "syntaxType": "ink", "syntaxString": "muted", "syntaxOperator": "muted", "syntaxPunctuation": "faint",
+		"thinkingMinimal": "faint", "thinkingLow": "mark", "thinkingMedium": "muted"
+	}
+}